velocious 1.0.549 → 1.0.552

package/README.md

@@ -141,6 +141,19 @@ Slowest 10 tests:
 
 The report is skipped for single-test runs. See [docs/testing-guidelines.md](docs/testing-guidelines.md).
 
+Prefer waiting for a real signal or condition over sleeping a fixed duration. `waitForEvent(emitter, eventName, {timeoutMs, filter})` resolves the instant a matching event fires (a background job finishing, a model update, a websocket message) and rejects on timeout; for polling an arbitrary condition, use awaitery's `waitFor`.
+
+```js
+import {waitForEvent} from "velocious/build/src/testing/test.js"
+import waitFor from "awaitery/build/wait-for.js"
+
+// Event-driven: resolves as soon as the matching event fires (no polling latency).
+const {result} = await waitForEvent(jobRunner, "jobFinished", {filter: (event) => event.jobId === jobId})
+
+// Condition polling: retries the callback until it stops throwing.
+await waitFor(() => expect(await Message.count()).toEqual(1))
+```
+
 Velocious captures console output emitted while each test executes, but does not print passing-test output by default. When a test fails, Velocious prints a truncated `Console output:` block for that failed test and saves the full captured log under `tmp/screenshots` next to failure screenshots/browser logs/HTML. Each failed test summary prints the saved console log path.
 
 Configure console output behavior in your testing config file.

package/build/background-jobs/json-socket.js

@@ -44,6 +44,19 @@ export default class JsonSocket extends EventEmitter {
      * the main's liveness sweep to drop a wedged/silent worker.
      * @type {number | undefined} */
     this.lastSeenAt = undefined
+    /**
+     * Internal test-only observability counter — NOT public API. Number of times
+     * `destroy()` has run, incremented immediately before the raw socket
+     * `destroy()` call so specs can assert the actual teardown method that ran
+     * rather than a self-reported flag. Do not read or depend on this outside tests.
+     * @type {number} */
+    this._destroyCallCount = 0
+    /**
+     * Internal test-only observability counter — NOT public API. Number of times
+     * `close()` has run, incremented immediately before the raw socket `end()`
+     * call. Do not read or depend on this outside tests.
+     * @type {number} */
+    this._closeCallCount = 0
     this.buffer = ""
     this.socket.setEncoding("utf8")
     this.socket.on("data", (chunk) => this._onData(String(chunk)))
@@ -91,6 +104,18 @@ export default class JsonSocket extends EventEmitter {
    * @returns {void}
    */
   close() {
+    this._closeCallCount++
     this.socket.end()
   }
+
+  /**
+   * Forcibly destroys the underlying socket. Unlike {@link close}, which
+   * half-closes gracefully via `end()`, this tears the connection down
+   * immediately so a stalled/aborted request does not leave the socket alive.
+   * @returns {void}
+   */
+  destroy() {
+    this._destroyCallCount++
+    this.socket.destroy()
+  }
 }

package/build/background-jobs/socket-request.js

@@ -15,6 +15,16 @@ export default class BackgroundJobsSocketRequest {
     this.host = host
     this.port = port
     this.role = role
+    /**
+     * Internal test-only observability reference — NOT public API. Holds the
+     * JsonSocket wrapper this request created so the timeout spec can inspect the
+     * wrapper's own `destroy()`/`close()` call counters — direct evidence of which
+     * teardown method actually ran, not a self-reported flag. Retains the single
+     * (already torn-down) wrapper for the request's lifetime. Do not expose or
+     * depend on this outside tests.
+     * @type {JsonSocket | undefined}
+     */
+    this._jsonSocket = undefined
   }
 
   /**
@@ -23,28 +33,60 @@ export default class BackgroundJobsSocketRequest {
    * @param {object} args - Options.
    * @param {(jsonSocket: JsonSocket) => void} args.onConnect - Called after the socket connects.
    * @param {(args: {message: import("./types.js").BackgroundJobSocketMessage, resolve: (value: T) => void, reject: (error: Error) => void}) => void} args.onMessage - Message handler.
+   * @param {AbortSignal} [args.signal] - Aborts the request; on abort the pending socket is destroyed and the promise rejects with the signal reason when it is an Error, otherwise with a generic abort Error.
    * @returns {Promise<T>} - Resolved request value.
    */
-  async run({onConnect, onMessage}) {
+  async run({onConnect, onMessage, signal}) {
     const socket = net.createConnection({host: this.host, port: this.port})
     const jsonSocket = new JsonSocket(socket)
 
+    this._jsonSocket = jsonSocket
+
     return await new Promise((resolve, reject) => {
       let finished = false
       /**
        * Finish.
+       * @param {object} options - Options.
+       * @param {boolean} [options.destroy] - Destroy the socket instead of gracefully closing it.
        * @param {() => void} callback - Finish callback.
        */
-      const finish = (callback) => {
+      const finish = ({destroy = false} = {}, callback) => {
         if (finished) return
         finished = true
+        if (signal) signal.removeEventListener("abort", onAbort)
         jsonSocket.removeAllListeners()
-        jsonSocket.close()
+
+        if (destroy) {
+          jsonSocket.destroy()
+        } else {
+          jsonSocket.close()
+        }
+
         callback()
       }
 
+      /**
+       * Handles a cooperative abort: tears down the pending socket and rejects
+       * with the signal reason when it is an Error.
+       * @returns {void}
+       */
+      const onAbort = () => {
+        const reason = signal?.reason
+
+        finish({destroy: true}, () => reject(reason instanceof Error ? reason : new Error("Background job socket request aborted")))
+      }
+
+      if (signal) {
+        if (signal.aborted) {
+          onAbort()
+          return
+        }
+
+        signal.addEventListener("abort", onAbort)
+      }
+
       jsonSocket.on("error", (error) => {
-        finish(() => reject(error))
+        finish({}, () => reject(error))
       })
 
       /**
@@ -54,8 +96,8 @@ export default class BackgroundJobsSocketRequest {
       jsonSocket.on("message", (message) => {
         onMessage({
           message,
-          resolve: (value) => finish(() => resolve(value)),
-          reject: (error) => finish(() => reject(error))
+          resolve: (value) => finish({}, () => resolve(value)),
+          reject: (error) => finish({}, () => reject(error))
         })
       })
 

package/build/background-jobs/status-reporter.js

@@ -15,11 +15,20 @@ export default class BackgroundJobsStatusReporter {
    * @param {import("../configuration.js").default} args.configuration - Configuration.
    * @param {string} [args.host] - Host.
    * @param {number} [args.port] - Port.
+   * @param {number} [args.attemptTimeoutMs] - Per-attempt socket-request timeout in milliseconds (default: 5000).
    */
-  constructor({configuration, host, port}) {
+  constructor({configuration, host, port, attemptTimeoutMs = 5000}) {
     this.configuration = configuration
     this.host = host
     this.port = port
+    this.attemptTimeoutMs = attemptTimeoutMs
+    /**
+     * Internal test-only observability state — NOT public API. References the most
+     * recent socket request so the timeout spec can inspect how its socket was torn
+     * down. Do not expose or depend on this outside tests.
+     * @type {BackgroundJobsSocketRequest | undefined}
+     */
+    this._lastRequest = undefined
     this.logger = new Logger(this)
   }
 
@@ -39,10 +48,13 @@ export default class BackgroundJobsStatusReporter {
     const host = this.host || config.host
     const port = typeof this.port === "number" ? this.port : config.port
 
-    await timeout({timeout: 5000}, async () => {
+    await timeout({timeout: this.attemptTimeoutMs}, async ({control}) => {
       const request = new BackgroundJobsSocketRequest({host, port, role: "reporter"})
 
+      this._lastRequest = request
+
       await request.run({
+        signal: control.signal,
         onConnect: (jsonSocket) => {
           jsonSocket.send({
             type: status === "completed" ? "job-complete" : "job-failed",

package/build/configuration-types.js

@@ -72,6 +72,7 @@
  * @property {function() : ?} [getConnection] - Custom connection factory override.
  * @property {string} [host] - Database host.
  * @property {boolean} [migrations] - Whether migrations are enabled for this database.
+ * @property {boolean} [multipleStatements] - (MySQL) Opt in to multi-statement queries so a whole structure SQL dump loads in one round-trip via `StructureSqlLoader`. Off by default; ordinary queries otherwise reject stacked statements.
  * @property {string} [password] - Password for the database user.
  * @property {number} [port] - Database port.
  * @property {string} [primaryKeyType] - Default type for implicit migration primary keys and references. Defaults to `uuid`.

package/build/database/advisory-lock-runner.js

@@ -1,6 +1,6 @@
 // @ts-check
 
-import timeout from "awaitery/build/timeout.js"
+import timeout, {TimeoutError} from "awaitery/build/timeout.js"
 
 /**
  * Thrown when an advisory lock could not be acquired before `timeoutMs` elapsed.
@@ -67,9 +67,12 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback after acquiring the advisory lock, waiting up to `timeoutMs`.
+   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+   * awaitery for cooperative cancellation (`control.check()`, `control.signal`,
+   * `control.timedOut`, `control.remaining()`).
    * @template T
    * @param {string} name - Lock name.
-   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
    * @param {{timeoutMs?: number | null, holdTimeoutMs?: number | null}} [args] - Lock and hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -87,9 +90,11 @@ export default class AdvisoryLockRunner {
 
   /**
    * Runs a callback only if the advisory lock can be acquired immediately.
+   * When a `holdTimeoutMs` is set the callback receives a `TimeoutControl` from
+   * awaitery for cooperative cancellation.
    * @template T
    * @param {string} name - Lock name.
-   * @param {() => Promise<T>} callback - Callback to invoke while the lock is held.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback to invoke while the lock is held.
    * @param {{holdTimeoutMs?: number | null}} [args] - Hold timeout options.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -108,7 +113,7 @@ export default class AdvisoryLockRunner {
   /**
    * Runs the lock holder callback and releases the lock from its owning connection.
    * @template T
-   * @param {{callback: () => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
+   * @param {{callback: (args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>, connection: import("./drivers/base.js").default, holdTimeoutMs?: number | null, name: string}} args - Locked callback args.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
   async runLockedCallback({callback, connection, holdTimeoutMs, name}) {
@@ -160,9 +165,13 @@ export default class AdvisoryLockRunner {
    * Runs `callback`, rejecting with `AdvisoryLockHoldTimeoutError` if it has
    * not settled within `holdTimeoutMs`. The callback is not cancelled; callers
    * use a dedicated advisory-lock connection so the lock can still be released.
+   *
+   * The callback receives a `TimeoutControl` from awaitery, enabling cooperative
+   * cancellation via `control.check()`, `control.signal`, `control.timedOut`,
+   * and `control.remaining()`.
    * @template T
    * @param {string} name - Lock name (for the error message).
-   * @param {() => Promise<T>} callback - Callback holding the lock.
+   * @param {(args?: {control: import("awaitery/build/timeout.js").TimeoutControl}) => Promise<T>} callback - Callback holding the lock.
    * @param {number | null} [holdTimeoutMs] - Max hold time; falsy disables the timeout.
    * @returns {Promise<T>} - Resolves with the callback result.
    */
@@ -174,15 +183,15 @@ export default class AdvisoryLockRunner {
     let callbackSettled = false
 
     try {
-      return await timeout({timeout: holdTimeoutMs}, async () => {
+      return await timeout({timeout: holdTimeoutMs}, async ({control}) => {
         try {
-          return await callback()
+          return await callback({control})
         } finally {
           callbackSettled = true
         }
       })
     } catch (error) {
-      if (!callbackSettled) {
+      if (!callbackSettled || error instanceof TimeoutError) {
         throw new AdvisoryLockHoldTimeoutError(`Advisory lock ${JSON.stringify(name)} held longer than ${holdTimeoutMs}ms`, {name})
       }
 

package/build/database/drivers/base.js

@@ -583,6 +583,18 @@ export default class VelociousDatabaseDriversBase {
     return null
   }
 
+  /**
+   * Executes a whole multi-statement structure SQL script in a single round-trip when
+   * the driver supports it, running on this connection (so the caller's foreign-key
+   * handling applies). Returns true if it ran the whole script; false when the caller
+   * should run the statements individually. The base driver has no batch path.
+   * @param {string} _structureSql - Full multi-statement structure SQL.
+   * @returns {Promise<boolean>} - Whether the script was executed as one batch.
+   */
+  async execStructureScript(_structureSql) {
+    return false
+  }
+
   /**
    * Runs get table by name.
    * @param {string} name - Name.

package/build/database/drivers/mssql/index.js

@@ -23,6 +23,17 @@ import Upsert from "./sql/upsert.js"
 import Update from "./sql/update.js"
 import UUID from "pure-uuid"
 
+/**
+ * SQL Server error number raised by `sp_releaseapplock` when the current
+ * session does not hold the requested application lock. Releasing a lock the
+ * session no longer holds is a normal race (a shared connection's final
+ * check-in may already have auto-released it), which the cross-driver
+ * `releaseAdvisoryLock` contract models by resolving to `false`. We translate
+ * this specific error into that result rather than letting it escape.
+ * @type {number}
+ */
+const APPLOCK_NOT_HELD_ERROR_NUMBER = 1223
+
 export default class VelociousDatabaseDriversMssql extends Base{
   async connect() {
     const args = this.getArgs()
@@ -640,18 +651,56 @@ export default class VelociousDatabaseDriversMssql extends Base{
 
   /**
    * Runs release advisory lock.
+   *
+   * `sp_releaseapplock` returns 0 when the lock was released, but SQL Server
+   * raises error {@link APPLOCK_NOT_HELD_ERROR_NUMBER} instead of returning a
+   * failure code when the session does not currently hold the lock. That
+   * error aborts the batch before the trailing `SELECT` can run, so we catch
+   * it and resolve to `false` to honor the cross-driver contract for an
+   * already-unheld lock.
    * @param {string} name - Lock name.
    * @returns {Promise<boolean>} - True if the lock was held by this session and has now been released.
    */
   async _releaseAdvisoryLock(name) {
-    const rows = await this.query(
-      `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
-    )
+    let rows
+
+    try {
+      rows = await this.query(
+        `DECLARE @velocious_advisory_lock_result INT; EXEC @velocious_advisory_lock_result = sp_releaseapplock @Resource = ${this.quote(name)}, @LockOwner = 'Session'; SELECT @velocious_advisory_lock_result AS velocious_advisory_lock_result`
+      )
+    } catch (error) {
+      if (this._isApplockNotHeldError(error)) return false
+
+      throw error
+    }
+
     const result = Number(rows?.[0]?.velocious_advisory_lock_result)
 
     return result === 0
   }
 
+  /**
+   * Detects the SQL Server "application lock is not currently held" error
+   * raised by `sp_releaseapplock`. It walks the wrapped-error cause chain
+   * because `query` re-wraps the driver's `RequestError` in a plain `Error`,
+   * and matches on the stable numeric error number rather than the message.
+   * @param {unknown} error - Error thrown while releasing the lock.
+   * @returns {boolean} - True if the error means the lock was not held by this session.
+   */
+  _isApplockNotHeldError(error) {
+    let current = error
+
+    while (current instanceof Error) {
+      const errorNumber = /** @type {{number?: unknown}} */ (current).number
+
+      if (typeof errorNumber === "number" && errorNumber === APPLOCK_NOT_HELD_ERROR_NUMBER) return true
+
+      current = current.cause
+    }
+
+    return false
+  }
+
   /**
    * Returns true if any session currently holds the application lock.
    *

package/build/database/drivers/mysql/index.js

@@ -190,6 +190,10 @@ export default class VelociousDatabaseDriversMysql extends Base{
 
     if ("username" in args) connectArgs["user"] = args["username"]
     if ("charset" in args) connectArgs["charset"] = args["charset"]
+    // Opt-in only. Lets a whole structure SQL dump run in one round-trip via
+    // {@link execStructureScript}; off by default so ordinary queries keep rejecting
+    // stacked statements.
+    if ("multipleStatements" in args) connectArgs["multipleStatements"] = Boolean(digg(args, "multipleStatements"))
 
     return connectArgs
   }
@@ -417,6 +421,36 @@ export default class VelociousDatabaseDriversMysql extends Base{
     })
   }
 
+  /**
+   * Executes a full multi-statement structure SQL script in one round-trip when the
+   * connection was configured with `multipleStatements: true`. Runs on the pooled
+   * connection so the caller's `SET FOREIGN_KEY_CHECKS = 0` applies. Returns false so
+   * the caller runs statements individually when multi-statement queries are off.
+   * @param {string} structureSql - Full multi-statement structure SQL.
+   * @returns {Promise<boolean>} - Whether the script was executed as one batch.
+   */
+  async execStructureScript(structureSql) {
+    if (!this.getArgs().multipleStatements) return false
+
+    // The batched pool call below bypasses Base#query, so re-run the same read-only
+    // write guard the per-statement path applies before executing the dump.
+    this._assertWritableQuery(structureSql)
+
+    if (!this.pool) await this.connect()
+    if (!this.pool) throw new Error("MySQL pool failed to initialize")
+
+    const pool = this.pool
+
+    await new Promise((resolve, reject) => {
+      pool.query(structureSql, (error) => {
+        if (error) reject(error)
+        else resolve(undefined)
+      })
+    })
+
+    return true
+  }
+
   /**
    * Runs query to sql.
    * @param {import("../../query/index.js").default} query - Query instance.

package/build/database/structure-sql-loader.js

@@ -31,17 +31,23 @@ export default class StructureSqlLoader {
     await db.disableForeignKeys()
 
     try {
-      if (executableConnection) {
-        await executableConnection.exec(structureSql)
-      } else {
-        for (const statement of statements) {
-          await db.query(statement)
+      // Prefer a single round-trip for the whole dump: a driver-native multi-statement
+      // batch (e.g. MySQL with `multipleStatements`) first, then a native `exec`
+      // connection (e.g. SQLite), and finally per-statement execution. Running the
+      // whole dump at once is far faster than issuing every CREATE separately.
+      if (!await db.execStructureScript(structureSql)) {
+        if (executableConnection) {
+          await executableConnection.exec(structureSql)
+        } else {
+          for (const statement of statements) {
+            await db.query(statement)
+          }
         }
       }
     } finally {
       await db.enableForeignKeys()
 
-      // The native `exec` path mutates the schema outside `Base#query`, so the
+      // The batch / native `exec` paths mutate the schema outside `Base#query`, so the
       // usual post-DDL schema-cache invalidation never runs. Clear it here so a
       // caller that read schema metadata before provisioning (e.g. an empty table
       // list) does not keep seeing the pre-load schema afterwards. Harmless for the

package/build/src/background-jobs/json-socket.d.ts

@@ -40,6 +40,19 @@ export default class JsonSocket extends JsonSocket_base {
      * the main's liveness sweep to drop a wedged/silent worker.
      * @type {number | undefined} */
     lastSeenAt: number | undefined;
+    /**
+     * Internal test-only observability counter — NOT public API. Number of times
+     * `destroy()` has run, incremented immediately before the raw socket
+     * `destroy()` call so specs can assert the actual teardown method that ran
+     * rather than a self-reported flag. Do not read or depend on this outside tests.
+     * @type {number} */
+    _destroyCallCount: number;
+    /**
+     * Internal test-only observability counter — NOT public API. Number of times
+     * `close()` has run, incremented immediately before the raw socket `end()`
+     * call. Do not read or depend on this outside tests.
+     * @type {number} */
+    _closeCallCount: number;
     buffer: string;
     /**
      * Runs on data.
@@ -58,6 +71,13 @@ export default class JsonSocket extends JsonSocket_base {
      * @returns {void}
      */
     close(): void;
+    /**
+     * Forcibly destroys the underlying socket. Unlike {@link close}, which
+     * half-closes gracefully via `end()`, this tears the connection down
+     * immediately so a stalled/aborted request does not leave the socket alive.
+     * @returns {void}
+     */
+    destroy(): void;
 }
 export {};
 //# sourceMappingURL=json-socket.d.ts.map

package/build/src/background-jobs/json-socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-socket.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/json-socket.js"],"names":[],"mappings":";AAIA;IACE;;;OAGG;IACH,oBAFW,OAAO,KAAK,EAAE,MAAM,EA4C9B;IAxCC,kCAAoB;IACpB;;oCAEgC;IAChC,UADU,MAAM,GAAG,SAAS,CACH;IACzB;;yBAEqB;IACrB,4BADU,OAAO,CACsB;IACvC;;yBAEqB;IACrB,oBADU,OAAO,CACa;IAC9B;;yBAEqB;IACrB,mBADU,OAAO,CACY;IAC7B,sBAAsB;IACtB,mBADW,OAAO,CACY;IAC9B;;yBAEqB;IACrB,mBADU,OAAO,CACY;IAC7B;;;;;yBAKqB;IACrB,mBADU,OAAO,CACa;IAC9B;;;oCAGgC;IAChC,YADU,MAAM,GAAG,SAAS,CACD;IAC3B,eAAgB;IAOlB;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;OAIG;IACH,cAHW,OAAC,GACC,IAAI,CAIhB;IAED;;;OAGG;IACH,SAFa,IAAI,CAIhB;CACF"}
+{"version":3,"file":"json-socket.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/json-socket.js"],"names":[],"mappings":";AAIA;IACE;;;OAGG;IACH,oBAFW,OAAO,KAAK,EAAE,MAAM,EAyD9B;IArDC,kCAAoB;IACpB;;oCAEgC;IAChC,UADU,MAAM,GAAG,SAAS,CACH;IACzB;;yBAEqB;IACrB,4BADU,OAAO,CACsB;IACvC;;yBAEqB;IACrB,oBADU,OAAO,CACa;IAC9B;;yBAEqB;IACrB,mBADU,OAAO,CACY;IAC7B,sBAAsB;IACtB,mBADW,OAAO,CACY;IAC9B;;yBAEqB;IACrB,mBADU,OAAO,CACY;IAC7B;;;;;yBAKqB;IACrB,mBADU,OAAO,CACa;IAC9B;;;oCAGgC;IAChC,YADU,MAAM,GAAG,SAAS,CACD;IAC3B;;;;;wBAKoB;IACpB,mBADU,MAAM,CACU;IAC1B;;;;wBAIoB;IACpB,iBADU,MAAM,CACQ;IACxB,eAAgB;IAOlB;;;;OAIG;IACH,eAHW,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;OAIG;IACH,cAHW,OAAC,GACC,IAAI,CAIhB;IAED;;;OAGG;IACH,SAFa,IAAI,CAKhB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAKhB;CACF"}

package/build/src/background-jobs/json-socket.js

@@ -42,6 +42,19 @@ export default class JsonSocket extends EventEmitter {
          * the main's liveness sweep to drop a wedged/silent worker.
          * @type {number | undefined} */
         this.lastSeenAt = undefined;
+        /**
+         * Internal test-only observability counter — NOT public API. Number of times
+         * `destroy()` has run, incremented immediately before the raw socket
+         * `destroy()` call so specs can assert the actual teardown method that ran
+         * rather than a self-reported flag. Do not read or depend on this outside tests.
+         * @type {number} */
+        this._destroyCallCount = 0;
+        /**
+         * Internal test-only observability counter — NOT public API. Number of times
+         * `close()` has run, incremented immediately before the raw socket `end()`
+         * call. Do not read or depend on this outside tests.
+         * @type {number} */
+        this._closeCallCount = 0;
         this.buffer = "";
         this.socket.setEncoding("utf8");
         this.socket.on("data", (chunk) => this._onData(String(chunk)));
@@ -85,7 +98,18 @@ export default class JsonSocket extends EventEmitter {
      * @returns {void}
      */
     close() {
+        this._closeCallCount++;
         this.socket.end();
     }
+    /**
+     * Forcibly destroys the underlying socket. Unlike {@link close}, which
+     * half-closes gracefully via `end()`, this tears the connection down
+     * immediately so a stalled/aborted request does not leave the socket alive.
+     * @returns {void}
+     */
+    destroy() {
+        this._destroyCallCount++;
+        this.socket.destroy();
+    }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"json-socket.js","sourceRoot":"","sources":["../../../src/background-jobs/json-socket.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport EventEmitter from \"../utils/event-emitter.js\"\n\nexport default class JsonSocket extends EventEmitter {\n  /**\n   * Runs constructor.\n   * @param {import(\"net\").Socket} socket - Socket instance.\n   */\n  constructor(socket) {\n    super()\n    this.socket = socket\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {string | undefined} */\n    this.workerId = undefined\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {boolean} */\n    this.supportsHandoffIdReporting = false\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {boolean} */\n    this.acceptsSpawnedJobs = true\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {boolean} */\n    this.acceptsForkedJobs = true\n    /** @type {boolean} */\n    this.acceptsPooledJobs = false\n    /**\n     * Narrows the runtime value to the documented type.\n     * @type {boolean} */\n    this.acceptsInlineJobs = true\n    /**\n     * Whether this worker advertised heartbeat support in its hello. Only\n     * heartbeat-capable workers are subject to the main's stale-liveness\n     * eviction; a legacy worker (e.g. mid rolling deploy) is exempt so its\n     * active leases are not released while it is still running them.\n     * @type {boolean} */\n    this.supportsHeartbeat = false\n    /**\n     * Last time (ms) the main saw any message from this worker socket; used by\n     * the main's liveness sweep to drop a wedged/silent worker.\n     * @type {number | undefined} */\n    this.lastSeenAt = undefined\n    /**\n     * Internal test-only observability counter — NOT public API. Number of times\n     * `destroy()` has run, incremented immediately before the raw socket\n     * `destroy()` call so specs can assert the actual teardown method that ran\n     * rather than a self-reported flag. Do not read or depend on this outside tests.\n     * @type {number} */\n    this._destroyCallCount = 0\n    /**\n     * Internal test-only observability counter — NOT public API. Number of times\n     * `close()` has run, incremented immediately before the raw socket `end()`\n     * call. Do not read or depend on this outside tests.\n     * @type {number} */\n    this._closeCallCount = 0\n    this.buffer = \"\"\n    this.socket.setEncoding(\"utf8\")\n    this.socket.on(\"data\", (chunk) => this._onData(String(chunk)))\n    this.socket.on(\"close\", () => this.emit(\"close\"))\n    this.socket.on(\"error\", (error) => this.emit(\"error\", error))\n  }\n\n  /**\n   * Runs on data.\n   * @param {string} chunk - Data chunk.\n   * @returns {void}\n   */\n  _onData(chunk) {\n    this.buffer += chunk\n\n    while (true) {\n      const newlineIndex = this.buffer.indexOf(\"\\n\")\n      if (newlineIndex === -1) break\n\n      const line = this.buffer.slice(0, newlineIndex).trim()\n      this.buffer = this.buffer.slice(newlineIndex + 1)\n\n      if (!line) continue\n\n      try {\n        const message = JSON.parse(line)\n        this.emit(\"message\", message)\n      } catch (error) {\n        this.emit(\"error\", error)\n      }\n    }\n  }\n\n  /**\n   * Runs send.\n   * @param {?} message - Message to send.\n   * @returns {void}\n   */\n  send(message) {\n    this.socket.write(`${JSON.stringify(message)}\\n`)\n  }\n\n  /**\n   * Runs close.\n   * @returns {void}\n   */\n  close() {\n    this._closeCallCount++\n    this.socket.end()\n  }\n\n  /**\n   * Forcibly destroys the underlying socket. Unlike {@link close}, which\n   * half-closes gracefully via `end()`, this tears the connection down\n   * immediately so a stalled/aborted request does not leave the socket alive.\n   * @returns {void}\n   */\n  destroy() {\n    this._destroyCallCount++\n    this.socket.destroy()\n  }\n}\n"]}

package/build/src/background-jobs/socket-request.d.ts

@@ -14,21 +14,33 @@ export default class BackgroundJobsSocketRequest {
     host: string;
     port: number;
     role: "client" | "reporter";
+    /**
+     * Internal test-only observability reference — NOT public API. Holds the
+     * JsonSocket wrapper this request created so the timeout spec can inspect the
+     * wrapper's own `destroy()`/`close()` call counters — direct evidence of which
+     * teardown method actually ran, not a self-reported flag. Retains the single
+     * (already torn-down) wrapper for the request's lifetime. Do not expose or
+     * depend on this outside tests.
+     * @type {JsonSocket | undefined}
+     */
+    _jsonSocket: JsonSocket | undefined;
     /**
      * Runs run.
      * @template T
      * @param {object} args - Options.
      * @param {(jsonSocket: JsonSocket) => void} args.onConnect - Called after the socket connects.
      * @param {(args: {message: import("./types.js").BackgroundJobSocketMessage, resolve: (value: T) => void, reject: (error: Error) => void}) => void} args.onMessage - Message handler.
+     * @param {AbortSignal} [args.signal] - Aborts the request; on abort the pending socket is destroyed and the promise rejects with the signal reason when it is an Error, otherwise with a generic abort Error.
      * @returns {Promise<T>} - Resolved request value.
      */
-    run<T>({ onConnect, onMessage }: {
+    run<T>({ onConnect, onMessage, signal }: {
         onConnect: (jsonSocket: JsonSocket) => void;
         onMessage: (args: {
             message: import("./types.js").BackgroundJobSocketMessage;
             resolve: (value: T) => void;
             reject: (error: Error) => void;
         }) => void;
+        signal?: AbortSignal | undefined;
     }): Promise<T>;
 }
 import JsonSocket from "./json-socket.js";

package/build/src/background-jobs/socket-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket-request.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/socket-request.js"],"names":[],"mappings":"AAKA;IACE;;;;;;OAMG;IACH,kCAJG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACsB,IAAI,EAAhC,QAAQ,GAAG,UAAU;KAC/B,EAKA;IAHC,aAAgB;IAChB,aAAgB;IAChB,4BAAgB;IAGlB;;;;;;;OAOG;IACH,IANa,CAAC,4BAEX;QAA+C,SAAS,EAAhD,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI;QAC8G,SAAS,EAAvJ,CAAC,IAAI,EAAE;YAAC,OAAO,EAAE,OAAO,YAAY,EAAE,0BAA0B,CAAC;YAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;YAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;SAAC,KAAK,IAAI;KAC/I,GAAU,OAAO,CAAC,CAAC,CAAC,CAyCtB;CACF;uBAhEsB,kBAAkB"}
+{"version":3,"file":"socket-request.d.ts","sourceRoot":"","sources":["../../../src/background-jobs/socket-request.js"],"names":[],"mappings":"AAKA;IACE;;;;;;OAMG;IACH,kCAJG;QAAqB,IAAI,EAAjB,MAAM;QACO,IAAI,EAAjB,MAAM;QACsB,IAAI,EAAhC,QAAQ,GAAG,UAAU;KAC/B,EAeA;IAbC,aAAgB;IAChB,aAAgB;IAChB,4BAAgB;IAChB;;;;;;;;OAQG;IACH,aAFU,UAAU,GAAG,SAAS,CAEJ;IAG9B;;;;;;;;OAQG;IACH,IAPa,CAAC,oCAEX;QAA+C,SAAS,EAAhD,CAAC,UAAU,EAAE,UAAU,KAAK,IAAI;QAC8G,SAAS,EAAvJ,CAAC,IAAI,EAAE;YAAC,OAAO,EAAE,OAAO,YAAY,EAAE,0BAA0B,CAAC;YAAC,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;YAAC,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;SAAC,KAAK,IAAI;QACpH,MAAM;KACjC,GAAU,OAAO,CAAC,CAAC,CAAC,CAwEtB;CACF;uBA1GsB,kBAAkB"}