rollbridge 0.1.49 → 0.1.55

package/AGENTS.md

@@ -61,6 +61,11 @@ external-supervisor migration path, not that atomic handoff.
 
 ## Validation and publication
 
+All tests use `@velocious/testing` declarations, hooks, and `expect` matchers.
+Do not import `node:test` or `node:assert`, or add assertion compatibility wrappers.
+Run every changed test file locally with `npx --no-install velocious-test test/<name>.test.js`
+and require it to pass before committing or pushing; lint or CI is not a substitute.
+
 The project is ESM JavaScript with JSDoc type checking. Package scripts are the
 source of truth: `npm run typecheck`, `npm run lint`, `npm test`, and the combined
 `npm run all-checks`. Run focused checks for the files changed; documentation-only

package/README.md

@@ -576,6 +576,7 @@ Inspect state:
 
 ```bash
 rollbridge status --config rollbridge.js
+rollbridge status --no-logs --config rollbridge.js
 ```
 
 `status` reports each managed process's `state`, `pid`, recent `logs`, last
@@ -587,6 +588,10 @@ and why it last started (`lastStartReason`: `deploy`, `crash`, `manual`, or
 `rssBytes`, `memoryRestarts`, `lastMemoryRestartAt`, and `children` (the sampled
 process tree — each group member's `pid`, `command`, and `rssBytes`).
 
+For machine lifecycle attestations that do not need captured process output,
+pass `--no-logs`. It returns the same status projection while omitting only each
+release, service, and singleton process's `logs` array.
+
 Print the recent captured stdout/stderr per process (a one-shot snapshot of the
 retained `outputLines`, not a live stream):
 

package/changelog.d/20260909120000-velocious-testing.md

@@ -0,0 +1 @@
+- Migrated all Rollbridge tests to `@velocious/testing` declarations, lifecycle APIs, and native `expect` matchers. Lint now rejects Node test and assertion imports in tests.

package/docs/cli.md

@@ -253,7 +253,7 @@ stays safe.
 ## `status`
 
 ```
-rollbridge status [--config <path>]
+rollbridge status [--config <path>] [--no-logs]
 ```
 
 Prints the daemon status JSON: the active release id, the proxy address, and —
@@ -264,6 +264,12 @@ Memory-supervised processes also report `rssBytes`, `memoryRestarts`,
 `lastMemoryRestartAt`, and `children` (the process tree: each group member's
 `pid`, `command`, and `rssBytes`).
 
+`--no-logs` omits only the captured `logs` array from release, service, and
+singleton process statuses. Use it for bounded machine-readable lifecycle
+attestations that do not need process output. The equivalent control request is
+`{"command":"status","includeLogs":false}`; omitted `includeLogs` continues to
+return the complete status payload.
+
 `daemonRuntime` identifies the immutable Rollbridge runtime serving the proxy:
 its runtime `format`, package `version`, content `digest`, and absolute `path`.
 `ensure-daemon` uses this attestation before reusing a responsive daemon.

package/docs/generation-deployment-contract.md

@@ -0,0 +1,9 @@
+# Generation deployment contract
+
+Rollbridge treats web authority, jobs-generation authority, durable transition state, and old-release draining as separate concerns.
+
+A successful activation-lifecycle deployment starts and health-checks the candidate, waits for the old generation's retirement/quiescence acknowledgement, activates the candidate jobs generation, switches web authority, checkpoints `committed`, and returns. The acknowledged old generation then continues draining and stopping asynchronously; deployment completion does not wait for that later work.
+
+Failed candidates never receive traffic. Recovery is exact-authority and journaled; no operator should edit durable state. A degraded incumbent keeps web authority while jobs remain explicitly degraded until a fresh generation commits.
+
+Persistent guardians may retain old processes, but new release processes must use current lifecycle semantics. Lifecycle command failures must retain bounded stdout/stderr and stage metadata. Runtime content digest is authoritative; package versions are compatibility metadata rather than unique code identity.

package/eslint.config.js

@@ -81,6 +81,14 @@ export default defineConfig([
       "no-unused-vars": ["error", {argsIgnorePattern: "^_", varsIgnorePattern: "^_", caughtErrorsIgnorePattern: "^_"}]
     }
   },
+  {
+    files: ["test/**/*.js"],
+    rules: {
+      "no-restricted-imports": ["error", {
+        patterns: [{group: ["node:test", "node:test/*", "test", "node:assert", "node:assert/*", "assert", "assert/*"], message: "Use @velocious/testing declarations and expect matchers."}]
+      }]
+    }
+  },
   jsdoc({
     config: "flat/recommended",
     files: ["**/*.{js,mjs,cjs}", "**/bin/rollbridge"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rollbridge",
-  "version": "0.1.49",
+  "version": "0.1.55",
   "description": "Zero-downtime process supervisor and local traffic switcher for deploy-managed apps.",
   "keywords": [
     "deploy",
@@ -29,7 +29,7 @@
     "all-checks": "npm run typecheck && npm run lint && npm test",
     "lint": "npm run eslint && npm run typecheck",
     "release:patch": "release-patch",
-    "test": "node --test test/*.test.js",
+    "test": "velocious-test test/*.test.js",
     "typecheck": "tsc --noEmit",
     "eslint": "eslint"
   },
@@ -44,6 +44,7 @@
     "@eslint/js": "^10.0.1",
     "@types/http-proxy": "^1.17.17",
     "@types/node": "^25.9.1",
+    "@velocious/testing": "^0.0.12",
     "eslint": "^10.4.0",
     "eslint-plugin-jsdoc": "^62.9.0",
     "globals": "^17.6.0",

package/src/cli.js

@@ -41,6 +41,7 @@ export async function runCli(argv) {
     .option("--boot-attestation <digest>", "Opaque bootstrap ownership attestation (requires the complete bootstrap release tuple)")
     .option("--takeover-owner", "Boot and health-check before retiring the current external owner")
     .option("--replace-owner", "Resume a prepared durable owner replacement")
+    .option("--reset-retired-owner", "Reset missing guardian identity from the exact committed bootstrap")
     .addOption(new Option("--guardian-daemon-log-path <path>").hideHelp())
     .addOption(new Option("--guardian-daemon-pid-path <path>").hideHelp())
     .addOption(new Option("--guardian-daemon-start-timeout-ms <ms>").hideHelp())
@@ -88,6 +89,12 @@ export async function runCli(argv) {
       process.once("SIGTERM", () => { void shutdown() })
 
       if (options.takeoverOwner && (!bootstrap || !bootstrap.attestation)) throw new Error("Daemon --takeover-owner requires the complete bootstrap release tuple and --boot-attestation.")
+      if (options.resetRetiredOwner && (!bootstrap || options.takeoverOwner || options.replaceOwner)) throw new Error("Daemon --reset-retired-owner requires the complete bootstrap tuple and cannot be combined with owner takeover/replacement.")
+
+      if (options.resetRetiredOwner) {
+        startupPromise = daemon.resetRetiredOwnerRecovery()
+        await startupPromise
+      }
 
       if (options.replaceOwner) {
         if (bootstrap || options.takeoverOwner) throw new Error("Daemon --replace-owner cannot be combined with bootstrap takeover options.")
@@ -95,7 +102,7 @@ export async function runCli(argv) {
         await startupPromise
       }
 
-      if (!options.takeoverOwner && !options.replaceOwner) {
+      if (!options.takeoverOwner && !options.replaceOwner && !options.resetRetiredOwner) {
         try {
           startupPromise = daemon.start({exposeControl: !bootstrap})
           await startupPromise
@@ -266,11 +273,12 @@ export async function runCli(argv) {
   program
     .command("status")
     .option("-c, --config <path>", "Config file path (defaults to rollbridge.js)")
+    .option("--no-logs", "Omit captured stdout/stderr from process statuses")
     .action(async (options) => {
       const configPath = await resolveConfigPath(options.config)
       const config = await loadConfig(configPath)
       const response = await sendControlCommand({
-        command: {command: "status"},
+        command: {command: "status", ...(options.logs ? {} : {includeLogs: false})},
         path: config.control.path
       })
 

package/src/daemon.js

@@ -27,6 +27,10 @@ const STATE_PERSIST_INTERVAL_MS = 5000
  * @typedef {"candidate_ready" | "retiring_previous" | "previous_retired" | "activating_candidate" | "restoring_previous" | "retiring_failed_candidate" | "degraded_active" | "committed_pending" | "committed" | "restoring_committed"} GenerationTransitionPhase
  * @typedef {{activationError?: string, activationLifecycle?: boolean, candidateReleaseId: string, candidateReleasePath: string, candidateRevision: string, compensationError?: string, configDigest: string, degradedIncumbent?: boolean, error?: string, journalRevision?: number, phase: GenerationTransitionPhase, previousReleaseId: string | null, startedAt: string, updatedAt: string}} GenerationTransition
  * @typedef {{activeReleaseId: string | null, application: string, bootstrap: BootstrapIdentity | undefined, control: import("./config.js").ControlConfig, daemonPid: number, daemonRuntime: import("./daemon-runtime.js").DaemonRuntimeIdentity | undefined, generationTransition?: GenerationTransition, ownerRecovery: {configDigest: string, ready: boolean} | undefined, ownerTransition?: OwnerTransition, orphans: {id: string, pid: number, releaseId: string | null}[], proxy: {host: string, port: number | undefined, upstreamHost: string}, releaseReferences: {releaseId: string, releasePath: string}[], releases: import("./release-group.js").ReleaseStatus[], services: ProcessStatus[], singletons: ProcessStatus[]}} DaemonStatus
+ * @typedef {Omit<import("./managed-process.js").ManagedProcessStatus, "logs">} ManagedProcessStatusWithoutLogs
+ * @typedef {Omit<import("./release-group.js").ReleaseStatus, "processes"> & {processes: ManagedProcessStatusWithoutLogs[]}} ReleaseStatusWithoutLogs
+ * @typedef {Omit<ProcessStatus, "process"> & {process: ManagedProcessStatusWithoutLogs}} ProcessStatusWithoutLogs
+ * @typedef {Omit<DaemonStatus, "releases" | "services" | "singletons"> & {releases: ReleaseStatusWithoutLogs[], services: ProcessStatusWithoutLogs[], singletons: ProcessStatusWithoutLogs[]}} DaemonStatusWithoutLogs
  * @typedef {{configDigest: string, format: number, guardian: {pid?: number, socketPath: string, token: string}, reconnectGraceMs: number}} OwnerRecoveryMetadata
  * @typedef {DaemonStatus & {recovery: OwnerRecoveryMetadata, serviceReleaseIds?: Record<string, string>, singletonReleaseIds?: Record<string, string>}} OwnerRecoverySnapshot
  * @typedef {{authority: JsonValue, config: import("./config.js").RollbridgeConfig, listenerConnectionSources?: Record<string, Record<string, {http: number, websocket: number}>>, listenerSourceId?: string, recovery?: {command: JsonValue, reconnectGraceMs: number, startupTimeoutMs: number}, releaseConfigs?: Record<string, import("./config.js").RollbridgeConfig>, retiredListenerHandoff?: number, serviceReleaseIds?: Record<string, string>, singletonReleaseIds?: Record<string, string>, snapshot: OwnerRecoverySnapshot}} PrivateOwnerState
@@ -186,6 +190,28 @@ export default class RollbridgeDaemon {
     return true
   }
 
+  /** Re-establishes durable guardian ownership from an exact committed external-owner bootstrap. */
+  async resetRetiredOwnerRecovery() {
+    if (!this.statePath || !this.config.ownerRecovery || !this.bootstrap) throw new Error("Retired owner reset requires ownerRecovery, statePath, and the exact bootstrap tuple")
+    const state = await readState(this.statePath)
+    const snapshot = state && typeof state === "object" && !Array.isArray(state) ? /** @type {OwnerRecoverySnapshot} */ (state) : undefined
+    const transition = snapshot?.generationTransition
+    const persistedBootstrap = snapshot?.bootstrap
+    const exactBootstrap = snapshot?.activeReleaseId === this.bootstrap.releaseId &&
+      persistedBootstrap?.releaseId === this.bootstrap.releaseId && persistedBootstrap?.releasePath === this.bootstrap.releasePath && persistedBootstrap?.revision === this.bootstrap.revision &&
+      transition?.phase === "committed" && transition.candidateReleaseId === this.bootstrap.releaseId && transition.candidateReleasePath === this.bootstrap.releasePath && transition.candidateRevision === this.bootstrap.revision
+    if (!snapshot || snapshot.recovery?.guardian || !exactBootstrap) throw new Error("Retired owner reset requires an exact committed bootstrap with missing guardian identity")
+    const control = await inspectControlSocket(this.config.control.path)
+    if (control.alive) throw new Error(`Retired owner reset refuses responsive control owner at ${this.config.control.path}`)
+    this.guardianIdentity = {socketPath: `${this.statePath}.guardian.sock`, token: crypto.randomBytes(32).toString("hex")}
+    this.guardian = new GuardianClient(this.guardianIdentity)
+    await this.guardian.launch()
+    this.guardianIdentity.pid = this.guardian.pid
+    this.watchOwnerReplacementEvents()
+    await this.guardian.claimOwner(this.config.ownerRecovery.reconnectGraceMs ?? 30000, this.ownerAuthority())
+    this.logger("retired owner guardian reset prepared", {guardianPid: this.guardianIdentity.pid ?? null, releaseId: this.bootstrap.releaseId})
+  }
+
   /** Connects to the durable process guardian and reconstructs a matching persisted owner snapshot. */
   async initializeOwnerRecovery() {
     if (!this.statePath) throw new Error("ownerRecovery requires statePath")
@@ -1349,7 +1375,7 @@ export default class RollbridgeDaemon {
     }
 
     if (commandName === "status") {
-      return this.status()
+      return this.status({includeLogs: statusIncludeLogs(data.includeLogs)})
     }
 
     if (commandName === "events") {
@@ -1942,14 +1968,10 @@ export default class RollbridgeDaemon {
     if (this.activeRelease !== previous) throw new Error(`Previous release ${previous.releaseId} is not the authoritative proxy target`)
     const activationConfig = previous.config.processes.find((processConfig) => processConfig.lifecycle.activateCommand !== undefined)
     const coordinator = activationConfig ? previous.getProcesses(activationConfig.id)[0]?.process : undefined
-    if (!coordinator || coordinator.status().lifecycleRole !== "retired") throw new Error(`Previous release ${previous.releaseId} does not retain a retired generation coordinator`)
-    if (!releaseOwnsLiveProxyTraffic(previous)) throw new Error(`Previous release ${previous.releaseId} no longer owns live proxy/web traffic`)
-    await candidate.drainAndStop(candidate.config.proxy.drainTimeoutMs, candidate.config)
-    const candidateProcesses = candidate.status().processes
+    const missingRetiredCoordinator = !coordinator && /^Process .+ is not retained for reactivation$/u.test(retirementFailure ?? "")
 
-    if (candidate.state !== "stopped" || candidateProcesses.some(({pid, state}) => pid !== undefined || (state !== "stopped" && state !== "failed"))) {
-      throw new Error(`Failed candidate ${candidate.releaseId} did not fully stop during retired-incumbent recovery`)
-    }
+    if ((!coordinator && !missingRetiredCoordinator) || (coordinator && coordinator.status().lifecycleRole !== "retired")) throw new Error(`Previous release ${previous.releaseId} does not retain a retired or terminally absent generation coordinator`)
+    if (!releaseOwnsLiveProxyTraffic(previous)) throw new Error(`Previous release ${previous.releaseId} no longer owns live proxy/web traffic`)
     if (this.activeRelease !== previous || !releaseOwnsLiveProxyTraffic(previous)) throw new Error(`Previous release ${previous.releaseId} lost live proxy/web authority during retired-incumbent recovery`)
     const result = /** @type {Record<string, JsonValue>} */ ({
       activeReleaseId: previous.releaseId,
@@ -1960,7 +1982,10 @@ export default class RollbridgeDaemon {
       recoveryStatus: "retired_incumbent_accepted"
     })
 
-    if (transition.phase === "degraded_active") return result
+    if (transition.phase === "degraded_active") {
+      if (candidate.state !== "stopped") void this.drainAndPrune(candidate, candidate.config)
+      return result
+    }
     const previousError = transition.error
     const previousPhase = transition.phase
     const previousJournalRevision = transition.journalRevision
@@ -1984,6 +2009,7 @@ export default class RollbridgeDaemon {
       }
       throw new Error(`retired-incumbent recovery checkpoint failed: ${error instanceof Error ? error.message : String(error)}`, {cause: error})
     }
+    if (candidate.state !== "stopped") void this.drainAndPrune(candidate, candidate.config)
     this.logger("retired incumbent accepted as jobs-degraded", result)
     return result
   }
@@ -2888,8 +2914,25 @@ export default class RollbridgeDaemon {
     return this.proxyPort
   }
 
-  /** @returns {DaemonStatus} Status payload. */
-  status() {
+  /**
+   * @overload
+   * @returns {DaemonStatus} Full status payload.
+   */
+  /**
+   * @overload
+   * @param {{includeLogs: false}} options - Log-free status response options.
+   * @returns {DaemonStatusWithoutLogs} Log-free status payload.
+   */
+  /**
+   * @overload
+   * @param {{includeLogs: boolean}} options - Status response options.
+   * @returns {DaemonStatus | DaemonStatusWithoutLogs} Status payload.
+   */
+  /**
+   * @param {{includeLogs?: boolean}} [options] - Status response options.
+   * @returns {DaemonStatus | DaemonStatusWithoutLogs} Status payload.
+   */
+  status({includeLogs = true} = {}) {
     // Re-check liveness and prune the dead permanently, so the list self-clears as the operator
     // stops the leftovers (e.g. via `rollbridge recover`). Pruning (not just filtering) matters:
     // a cleared orphan must not reappear if the OS later recycles its pid for an unrelated process.
@@ -2899,7 +2942,7 @@ export default class RollbridgeDaemon {
     const singletonOwnerReleaseIds = new Set(this.singletonReleaseIds.values())
     const transitionReleaseIds = this.generationTransitionReleaseIds()
 
-    return {
+    const status = {
       activeReleaseId: this.activeRelease ? this.activeRelease.releaseId : null,
       application: this.config.application,
       bootstrap: this.bootstrap ? {...this.bootstrap} : undefined,
@@ -2930,6 +2973,8 @@ export default class RollbridgeDaemon {
         process: processInstance.status()
       }))
     }
+
+    return includeLogs ? status : withoutStatusProcessLogs(status)
   }
 }
 
@@ -2941,6 +2986,50 @@ export function ownerConfigDigest(config) {
   return crypto.createHash("sha256").update(JSON.stringify(config)).digest("hex")
 }
 
+/**
+ * Removes captured output from a live status response without changing any other status field.
+ * @param {DaemonStatus} status - Full status payload.
+ * @returns {DaemonStatusWithoutLogs} Log-free status payload.
+ */
+function withoutStatusProcessLogs(status) {
+  return {
+    ...status,
+    releases: status.releases.map((release) => ({
+      ...release,
+      processes: release.processes.map(withoutProcessLogs)
+    })),
+    services: status.services.map(({process, ...service}) => ({
+      ...service,
+      process: withoutProcessLogs(process)
+    })),
+    singletons: status.singletons.map(({process, ...singleton}) => ({
+      ...singleton,
+      process: withoutProcessLogs(process)
+    }))
+  }
+}
+
+/**
+ * @param {import("./managed-process.js").ManagedProcessStatus} processStatus - Full managed-process status.
+ * @returns {ManagedProcessStatusWithoutLogs} Status without captured process output.
+ */
+function withoutProcessLogs(processStatus) {
+  const {logs: _logs, ...withoutLogs} = processStatus
+
+  return withoutLogs
+}
+
+/**
+ * @param {JsonValue} value - Optional status request field.
+ * @returns {boolean} Whether captured process output is included.
+ */
+function statusIncludeLogs(value) {
+  if (value === undefined) return true
+  if (typeof value !== "boolean") throw new Error("includeLogs must be a boolean")
+
+  return value
+}
+
 /**
  * @param {PrivateOwnerState} transfer - Authenticated private incumbent state.
  * @param {GenerationTransition} transition - Unresolved generation transition.
@@ -2968,6 +3057,7 @@ function terminalRetirementFailure(failure) {
   return typeof failure === "string" && (
     /^Cannot activate .+ generation from retired$/iu.test(failure) ||
     /^activate command exited non-zero with status \d+$/u.test(failure) ||
+    /^Process .+ is not retained for reactivation$/u.test(failure) ||
     /^Release .+ retirement quiescence failed: quiet command exited non-zero with status \d+$/u.test(failure)
   )
 }

package/src/process-guardian.js

@@ -631,7 +631,11 @@ async function execute(request, socket) {
       },
       shouldRestart: () => record.desired
     }
-    const managedProcess = legacyGuardian
+    // Only process keys inventoried from the legacy guardian remain delegated to it.
+    // New release processes must be owned by the current guardian so current lifecycle
+    // fields (including activation timeouts) are enforced instead of downgraded by an
+    // older guardian protocol implementation.
+    const managedProcess = recoversLegacyProcess && legacyGuardian
       ? legacyGuardian.process(request.key, managedDefinition)
       : new ManagedProcess(managedDefinition)
 

package/src/release-group.js

@@ -1,5 +1,6 @@
 // @ts-check
 
+import {spawn} from "node:child_process"
 import {EventEmitter} from "node:events"
 import ManagedProcess from "./managed-process.js"
 import {findAvailablePort} from "./port-allocator.js"
@@ -14,6 +15,40 @@ import {waitForHealth} from "./health.js"
  * @typedef {{count?: number, guardianKey?: string, index?: number, instanceId?: string, shouldRestart?: () => boolean}} BuildProcessOptions
  */
 
+
+/**
+ * Runs a lifecycle authority command in the current daemon so nested legacy guardians
+ * cannot silently downgrade lifecycle timeout semantics for newly deployed processes.
+ * @param {{command: string, cwd: string, env: Record<string, string>, label: string, timeoutMs: number}} options - Command contract.
+ * @returns {Promise<void>} Completion after an acknowledged command.
+ */
+async function runLifecycleCommand({command, cwd, env, label, timeoutMs}) {
+  await /** @type {Promise<void>} */ (new Promise((resolve, reject) => {
+    const child = spawn(command, {cwd, detached: true, env: {...process.env, ...env}, shell: true, stdio: "ignore"})
+    let settled = false
+    /** @param {Error | undefined} error - Completion failure. */
+    /** @param {Error | undefined} error - Completion failure. */
+    const finish = (error) => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (error) reject(error)
+      else resolve()
+    }
+    const timer = setTimeout(() => {
+      if (child.pid) {
+        try { process.kill(-child.pid, "SIGKILL") } catch { /* The command already exited. */ }
+      }
+      finish(new Error(`${label} timed out after ${timeoutMs}ms`))
+    }, timeoutMs)
+    child.once("error", finish)
+    child.once("exit", (code, signal) => {
+      if (code === 0) finish(undefined)
+      else finish(new Error(`${label} exited non-zero with ${signal ? `signal ${signal}` : `status ${code ?? "unknown"}`}`))
+    })
+  }))
+}
+
 /**
  * @param {string} id - Process id.
  * @returns {string} Environment suffix.
@@ -276,7 +311,19 @@ export default class ReleaseGroup extends EventEmitter {
     const [instance] = this.getProcesses(processConfig.id)
 
     if (!instance) throw new Error(`Generation activation process ${processConfig.id} is not running for release ${this.releaseId}`)
-    await instance.process.activateStrict()
+    if (instance.process.constructor.name === ManagedProcess.name) {
+      await instance.process.activateStrict()
+    } else {
+      const definition = this.processDefinition(processConfig)
+      await runLifecycleCommand({
+        command: /** @type {string} */ (processConfig.lifecycle.activateCommand),
+        cwd: /** @type {string} */ (definition.cwd),
+        env: /** @type {Record<string, string>} */ (definition.env),
+        label: "activate command",
+        timeoutMs: processConfig.lifecycle.activateTimeoutMs ?? 30000
+      })
+      await instance.process.setLifecycleRole("active")
+    }
   }
 
   /** Restores the retained generation coordinator to its active role in place. */

package/test/completion.test.js

@@ -1,9 +1,10 @@
 // @ts-check
 
-import assert from "node:assert/strict"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {runCli} from "../src/cli.js"
 
+describe("completion", () => {
+
 /**
  * Runs the CLI while capturing stdout, stderr, and the resulting exit code.
  * @param {string[]} argv - Process argv.
@@ -39,29 +40,30 @@ async function capture(argv) {
 test("completion bash prints a sourceable script with commands and option flags", async () => {
   const {code, output} = await capture(["node", "rollbridge", "completion", "bash"])
 
-  assert.notEqual(code, 1)
-  assert.match(output, /complete -F _rollbridge rollbridge/)
-  assert.match(output, /compgen -W "daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion"/)
+  expect(code).not.toBe(1)
+  expect(output).toMatch(/complete -F _rollbridge rollbridge/)
+  expect(output).toMatch(/compgen -W "daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion"/)
   // A command's own options are completed after the command.
-  assert.match(output, /deploy\)\n\s+opts="[^"]*--release-path[^"]*"/)
-  assert.match(output, /recover-generation-transition\)\n\s+opts="--config --release-path --release-id --revision --previous-release-id --accept-retired-incumbent"/)
-  assert.match(output, /ensure-daemon\)\n\s+opts="[^"]*--daemon-runtime-path[^"]*"/)
-  assert.match(output, /restart\)\n\s+opts="[^"]*--policy[^"]*"/)
+  expect(output).toMatch(/deploy\)\n\s+opts="[^"]*--release-path[^"]*"/)
+  expect(output).toMatch(/recover-generation-transition\)\n\s+opts="--config --release-path --release-id --revision --previous-release-id --accept-retired-incumbent"/)
+  expect(output).toMatch(/ensure-daemon\)\n\s+opts="[^"]*--daemon-runtime-path[^"]*"/)
+  expect(output).toMatch(/restart\)\n\s+opts="[^"]*--policy[^"]*"/)
 })
 
 test("completion zsh prints a #compdef script with per-command options", async () => {
   const {output} = await capture(["node", "rollbridge", "completion", "zsh"])
 
-  assert.match(output, /^#compdef rollbridge/)
-  assert.match(output, /compdef _rollbridge rollbridge/)
-  assert.match(output, /commands=\(daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion\)/)
-  assert.match(output, /recover-generation-transition\) compadd -- --config --release-path --release-id --revision --previous-release-id --accept-retired-incumbent/)
-  assert.match(output, /events\) compadd -- [^\n]*--limit/)
+  expect(output).toMatch(/^#compdef rollbridge/)
+  expect(output).toMatch(/compdef _rollbridge rollbridge/)
+  expect(output).toMatch(/commands=\(daemon deploy rollback recover-generation-transition ensure-daemon status stop restart shutdown validate doctor logs events predeploy-cleanup recover completion\)/)
+  expect(output).toMatch(/recover-generation-transition\) compadd -- --config --release-path --release-id --revision --previous-release-id --accept-retired-incumbent/)
+  expect(output).toMatch(/events\) compadd -- [^\n]*--limit/)
 })
 
 test("completion rejects an unsupported shell with a non-zero exit code", async () => {
   const {code, errorOutput} = await capture(["node", "rollbridge", "completion", "fish"])
 
-  assert.equal(code, 1)
-  assert.match(errorOutput, /Unsupported shell "fish"\. Supported shells: bash, zsh\./)
+  expect(code).toBe(1)
+  expect(errorOutput).toMatch(/Unsupported shell "fish"\. Supported shells: bash, zsh\./)
+})
 })

package/test/config-examples.test.js

@@ -1,34 +1,32 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {fileURLToPath} from "node:url"
 import {loadConfig} from "../src/config.js"
 
+describe("config-examples", () => {
+
 const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..")
 
 test("TensorBuzz example config loads", async () => {
   const config = await loadConfig(path.join(repoRoot, "examples", "tensorbuzz.com.js"))
 
-  assert.equal(config.application, "tensorbuzz")
-  assert.equal(config.control.path, "/tmp/rollbridge-tensorbuzz.sock")
-  assert.equal(config.proxy.host, "127.0.0.1")
-  assert.equal(config.proxy.port, 4500)
-  assert.equal(config.proxy.healthPath, "/ping")
-  assert.deepEqual(
-    config.processes.map((processConfig) => [processConfig.id, processConfig.policy]),
-    [
+  expect(config.application).toBe("tensorbuzz")
+  expect(config.control.path).toBe("/tmp/rollbridge-tensorbuzz.sock")
+  expect(config.proxy.host).toBe("127.0.0.1")
+  expect(config.proxy.port).toBe(4500)
+  expect(config.proxy.healthPath).toBe("/ping")
+  expect(config.processes.map((processConfig) => [processConfig.id, processConfig.policy])).toEqual([
       ["beacon", "service"],
       ["background-jobs-main", "service"],
       ["background-jobs-worker", "companion"],
       ["web", "proxied"]
-    ]
-  )
-  assert.equal(config.processes[2].lifecycle.reactivateCommand, "appctl jobs-worker-reactivate --pid $ROLLBRIDGE_PID")
-  assert.equal(config.processes[3].env.VELOCIOUS_BACKGROUND_JOBS_PORT, "{{ports.background-jobs-main}}")
+    ])
+  expect(config.processes[2].lifecycle.reactivateCommand).toBe("appctl jobs-worker-reactivate --pid $ROLLBRIDGE_PID")
+  expect(config.processes[3].env.VELOCIOUS_BACKGROUND_JOBS_PORT).toBe("{{ports.background-jobs-main}}")
 })
 
 test("loadConfig resolves a config module that exports a function", async () => {
@@ -50,11 +48,12 @@ test("loadConfig resolves a config module that exports a function", async () =>
   try {
     const config = await loadConfig(configPath)
 
-    assert.equal(config.application, "computed-app")
-    assert.equal(config.proxy.port, 8190)
-    assert.equal(config.processes[0].id, "web")
+    expect(config.application).toBe("computed-app")
+    expect(config.proxy.port).toBe(8190)
+    expect(config.processes[0].id).toBe("web")
   } finally {
     delete process.env.ROLLBRIDGE_TEST_APP
     await fs.rm(dir, {force: true, recursive: true})
   }
 })
+})

package/test/config-path.test.js

@@ -1,13 +1,14 @@
 // @ts-check
 
-import assert from "node:assert/strict"
 import fs from "node:fs/promises"
 import os from "node:os"
 import path from "node:path"
-import test from "node:test"
+import {describe, expect, test} from "@velocious/testing"
 import {loadConfig, resolveConfigPath} from "../src/config.js"
 import {runCli} from "../src/cli.js"
 
+describe("config-path", () => {
+
 const validConfig = {
   application: "demo",
   control: {path: "/tmp/rollbridge-config-path.sock"},
@@ -34,7 +35,7 @@ test("resolveConfigPath returns an explicit path unchanged", async () => {
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-cfgpath-"))
 
   try {
-    assert.equal(await resolveConfigPath("/somewhere/custom.js", dir), "/somewhere/custom.js")
+    expect(await resolveConfigPath("/somewhere/custom.js", dir)).toBe("/somewhere/custom.js")
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
@@ -46,7 +47,7 @@ test("resolveConfigPath resolves rollbridge.js in the working directory", async
   try {
     await writeConfigModule(dir)
 
-    assert.equal(await resolveConfigPath(undefined, dir), path.join(dir, "rollbridge.js"))
+    expect(await resolveConfigPath(undefined, dir)).toBe(path.join(dir, "rollbridge.js"))
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
@@ -56,10 +57,7 @@ test("resolveConfigPath throws an actionable error when no default config exists
   const dir = await fs.mkdtemp(path.join(os.tmpdir(), "rollbridge-cfgpath-"))
 
   try {
-    await assert.rejects(
-      () => resolveConfigPath(undefined, dir),
-      /No config file found.*rollbridge\.js/
-    )
+    await expect(resolveConfigPath(undefined, dir)).rejects.toThrow(/No config file found.*rollbridge\.js/)
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
@@ -70,11 +68,11 @@ test("loadConfig reloads a changed CommonJS module", async () => {
   const configPath = await writeConfigModule(dir)
 
   try {
-    assert.equal((await loadConfig(configPath)).application, "demo")
+    expect((await loadConfig(configPath)).application).toBe("demo")
 
     await fs.writeFile(configPath, `module.exports = ${JSON.stringify({...validConfig, application: "updated"}, null, 2)}\n`)
 
-    assert.equal((await loadConfig(configPath)).application, "updated")
+    expect((await loadConfig(configPath)).application).toBe("updated")
   } finally {
     await fs.rm(dir, {force: true, recursive: true})
   }
@@ -101,5 +99,6 @@ test("validate CLI command resolves the default config when --config is omitted"
     await fs.rm(dir, {force: true, recursive: true})
   }
 
-  assert.match(lines.join("\n"), /rollbridge\.js is valid: 1 process, proxy on 127\.0\.0\.1:8182\./)
+  expect(lines.join("\n")).toMatch(/rollbridge\.js is valid: 1 process, proxy on 127\.0\.0\.1:8182\./)
+})
 })