velocious 1.0.551 → 1.0.552

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/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"}

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

@@ -13,6 +13,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;
     }
     /**
      * Runs run.
@@ -20,27 +30,54 @@ 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));
             });
             /**
              * Handles the socket response message.
@@ -49,8 +86,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))
                 });
             });
             socket.on("connect", () => {
@@ -60,4 +97,4 @@ export default class BackgroundJobsSocketRequest {
         });
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic29ja2V0LXJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYmFja2dyb3VuZC1qb2JzL3NvY2tldC1yZXF1ZXN0LmpzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFlBQVk7QUFFWixPQUFPLEdBQUcsTUFBTSxLQUFLLENBQUE7QUFDckIsT0FBTyxVQUFVLE1BQU0sa0JBQWtCLENBQUE7QUFFekMsTUFBTSxDQUFDLE9BQU8sT0FBTywyQkFBMkI7SUFDOUM7Ozs7OztPQU1HO0lBQ0gsWUFBWSxFQUFDLElBQUksRUFBRSxJQUFJLEVBQUUsSUFBSSxFQUFDO1FBQzVCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBQ2hCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO1FBQ2hCLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxDQUFBO0lBQ2xCLENBQUM7SUFFRDs7Ozs7OztPQU9HO0lBQ0gsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFDLFNBQVMsRUFBRSxTQUFTLEVBQUM7UUFDOUIsTUFBTSxNQUFNLEdBQUcsR0FBRyxDQUFDLGdCQUFnQixDQUFDLEVBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUUsSUFBSSxFQUFFLElBQUksQ0FBQyxJQUFJLEVBQUMsQ0FBQyxDQUFBO1FBQ3ZFLE1BQU0sVUFBVSxHQUFHLElBQUksVUFBVSxDQUFDLE1BQU0sQ0FBQyxDQUFBO1FBRXpDLE9BQU8sTUFBTSxJQUFJLE9BQU8sQ0FBQyxDQUFDLE9BQU8sRUFBRSxNQUFNLEVBQUUsRUFBRTtZQUMzQyxJQUFJLFFBQVEsR0FBRyxLQUFLLENBQUE7WUFDcEI7OztlQUdHO1lBQ0gsTUFBTSxNQUFNLEdBQUcsQ0FBQyxRQUFRLEVBQUUsRUFBRTtnQkFDMUIsSUFBSSxRQUFRO29CQUFFLE9BQU07Z0JBQ3BCLFFBQVEsR0FBRyxJQUFJLENBQUE7Z0JBQ2YsVUFBVSxDQUFDLGtCQUFrQixFQUFFLENBQUE7Z0JBQy9CLFVBQVUsQ0FBQyxLQUFLLEVBQUUsQ0FBQTtnQkFDbEIsUUFBUSxFQUFFLENBQUE7WUFDWixDQUFDLENBQUE7WUFFRCxVQUFVLENBQUMsRUFBRSxDQUFDLE9BQU8sRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFO2dCQUMvQixNQUFNLENBQUMsR0FBRyxFQUFFLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7WUFDN0IsQ0FBQyxDQUFDLENBQUE7WUFFRjs7O2VBR0c7WUFDSCxVQUFVLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxDQUFDLE9BQU8sRUFBRSxFQUFFO2dCQUNuQyxTQUFTLENBQUM7b0JBQ1IsT0FBTztvQkFDUCxPQUFPLEVBQUUsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLE1BQU0sQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLENBQUM7b0JBQ2hELE1BQU0sRUFBRSxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsTUFBTSxDQUFDLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsQ0FBQztpQkFDL0MsQ0FBQyxDQUFBO1lBQ0osQ0FBQyxDQUFDLENBQUE7WUFFRixNQUFNLENBQUMsRUFBRSxDQUFDLFNBQVMsRUFBRSxHQUFHLEVBQUU7Z0JBQ3hCLFVBQVUsQ0FBQyxJQUFJLENBQUMsRUFBQyxJQUFJLEVBQUUsT0FBTyxFQUFFLElBQUksRUFBRSxJQUFJLENBQUMsSUFBSSxFQUFDLENBQUMsQ0FBQTtnQkFDakQsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFBO1lBQ3ZCLENBQUMsQ0FBQyxDQUFBO1FBQ0osQ0FBQyxDQUFDLENBQUE7SUFDSixDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBAdHMtY2hlY2tcblxuaW1wb3J0IG5ldCBmcm9tIFwibmV0XCJcbmltcG9ydCBKc29uU29ja2V0IGZyb20gXCIuL2pzb24tc29ja2V0LmpzXCJcblxuZXhwb3J0IGRlZmF1bHQgY2xhc3MgQmFja2dyb3VuZEpvYnNTb2NrZXRSZXF1ZXN0IHtcbiAgLyoqXG4gICAqIFJ1bnMgY29uc3RydWN0b3IuXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gT3B0aW9ucy5cbiAgICogQHBhcmFtIHtzdHJpbmd9IGFyZ3MuaG9zdCAtIEhvc3QuXG4gICAqIEBwYXJhbSB7bnVtYmVyfSBhcmdzLnBvcnQgLSBQb3J0LlxuICAgKiBAcGFyYW0ge1wiY2xpZW50XCIgfCBcInJlcG9ydGVyXCJ9IGFyZ3Mucm9sZSAtIFNvY2tldCByb2xlLlxuICAgKi9cbiAgY29uc3RydWN0b3Ioe2hvc3QsIHBvcnQsIHJvbGV9KSB7XG4gICAgdGhpcy5ob3N0ID0gaG9zdFxuICAgIHRoaXMucG9ydCA9IHBvcnRcbiAgICB0aGlzLnJvbGUgPSByb2xlXG4gIH1cblxuICAvKipcbiAgICogUnVucyBydW4uXG4gICAqIEB0ZW1wbGF0ZSBUXG4gICAqIEBwYXJhbSB7b2JqZWN0fSBhcmdzIC0gT3B0aW9ucy5cbiAgICogQHBhcmFtIHsoanNvblNvY2tldDogSnNvblNvY2tldCkgPT4gdm9pZH0gYXJncy5vbkNvbm5lY3QgLSBDYWxsZWQgYWZ0ZXIgdGhlIHNvY2tldCBjb25uZWN0cy5cbiAgICogQHBhcmFtIHsoYXJnczoge21lc3NhZ2U6IGltcG9ydChcIi4vdHlwZXMuanNcIikuQmFja2dyb3VuZEpvYlNvY2tldE1lc3NhZ2UsIHJlc29sdmU6ICh2YWx1ZTogVCkgPT4gdm9pZCwgcmVqZWN0OiAoZXJyb3I6IEVycm9yKSA9PiB2b2lkfSkgPT4gdm9pZH0gYXJncy5vbk1lc3NhZ2UgLSBNZXNzYWdlIGhhbmRsZXIuXG4gICAqIEByZXR1cm5zIHtQcm9taXNlPFQ+fSAtIFJlc29sdmVkIHJlcXVlc3QgdmFsdWUuXG4gICAqL1xuICBhc3luYyBydW4oe29uQ29ubmVjdCwgb25NZXNzYWdlfSkge1xuICAgIGNvbnN0IHNvY2tldCA9IG5ldC5jcmVhdGVDb25uZWN0aW9uKHtob3N0OiB0aGlzLmhvc3QsIHBvcnQ6IHRoaXMucG9ydH0pXG4gICAgY29uc3QganNvblNvY2tldCA9IG5ldyBKc29uU29ja2V0KHNvY2tldClcblxuICAgIHJldHVybiBhd2FpdCBuZXcgUHJvbWlzZSgocmVzb2x2ZSwgcmVqZWN0KSA9PiB7XG4gICAgICBsZXQgZmluaXNoZWQgPSBmYWxzZVxuICAgICAgLyoqXG4gICAgICAgKiBGaW5pc2guXG4gICAgICAgKiBAcGFyYW0geygpID0+IHZvaWR9IGNhbGxiYWNrIC0gRmluaXNoIGNhbGxiYWNrLlxuICAgICAgICovXG4gICAgICBjb25zdCBmaW5pc2ggPSAoY2FsbGJhY2spID0+IHtcbiAgICAgICAgaWYgKGZpbmlzaGVkKSByZXR1cm5cbiAgICAgICAgZmluaXNoZWQgPSB0cnVlXG4gICAgICAgIGpzb25Tb2NrZXQucmVtb3ZlQWxsTGlzdGVuZXJzKClcbiAgICAgICAganNvblNvY2tldC5jbG9zZSgpXG4gICAgICAgIGNhbGxiYWNrKClcbiAgICAgIH1cblxuICAgICAganNvblNvY2tldC5vbihcImVycm9yXCIsIChlcnJvcikgPT4ge1xuICAgICAgICBmaW5pc2goKCkgPT4gcmVqZWN0KGVycm9yKSlcbiAgICAgIH0pXG5cbiAgICAgIC8qKlxuICAgICAgICogSGFuZGxlcyB0aGUgc29ja2V0IHJlc3BvbnNlIG1lc3NhZ2UuXG4gICAgICAgKiBAcGFyYW0ge2ltcG9ydChcIi4vdHlwZXMuanNcIikuQmFja2dyb3VuZEpvYlNvY2tldE1lc3NhZ2V9IG1lc3NhZ2UgLSBTb2NrZXQgbWVzc2FnZS5cbiAgICAgICAqL1xuICAgICAganNvblNvY2tldC5vbihcIm1lc3NhZ2VcIiwgKG1lc3NhZ2UpID0+IHtcbiAgICAgICAgb25NZXNzYWdlKHtcbiAgICAgICAgICBtZXNzYWdlLFxuICAgICAgICAgIHJlc29sdmU6ICh2YWx1ZSkgPT4gZmluaXNoKCgpID0+IHJlc29sdmUodmFsdWUpKSxcbiAgICAgICAgICByZWplY3Q6IChlcnJvcikgPT4gZmluaXNoKCgpID0+IHJlamVjdChlcnJvcikpXG4gICAgICAgIH0pXG4gICAgICB9KVxuXG4gICAgICBzb2NrZXQub24oXCJjb25uZWN0XCIsICgpID0+IHtcbiAgICAgICAganNvblNvY2tldC5zZW5kKHt0eXBlOiBcImhlbGxvXCIsIHJvbGU6IHRoaXMucm9sZX0pXG4gICAgICAgIG9uQ29ubmVjdChqc29uU29ja2V0KVxuICAgICAgfSlcbiAgICB9KVxuICB9XG59XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"socket-request.js","sourceRoot":"","sources":["../../../src/background-jobs/socket-request.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport net from \"net\"\nimport JsonSocket from \"./json-socket.js\"\n\nexport default class BackgroundJobsSocketRequest {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options.\n   * @param {string} args.host - Host.\n   * @param {number} args.port - Port.\n   * @param {\"client\" | \"reporter\"} args.role - Socket role.\n   */\n  constructor({host, port, role}) {\n    this.host = host\n    this.port = port\n    this.role = role\n    /**\n     * Internal test-only observability reference — NOT public API. Holds the\n     * JsonSocket wrapper this request created so the timeout spec can inspect the\n     * wrapper's own `destroy()`/`close()` call counters — direct evidence of which\n     * teardown method actually ran, not a self-reported flag. Retains the single\n     * (already torn-down) wrapper for the request's lifetime. Do not expose or\n     * depend on this outside tests.\n     * @type {JsonSocket | undefined}\n     */\n    this._jsonSocket = undefined\n  }\n\n  /**\n   * Runs run.\n   * @template T\n   * @param {object} args - Options.\n   * @param {(jsonSocket: JsonSocket) => void} args.onConnect - Called after the socket connects.\n   * @param {(args: {message: import(\"./types.js\").BackgroundJobSocketMessage, resolve: (value: T) => void, reject: (error: Error) => void}) => void} args.onMessage - Message handler.\n   * @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.\n   * @returns {Promise<T>} - Resolved request value.\n   */\n  async run({onConnect, onMessage, signal}) {\n    const socket = net.createConnection({host: this.host, port: this.port})\n    const jsonSocket = new JsonSocket(socket)\n\n    this._jsonSocket = jsonSocket\n\n    return await new Promise((resolve, reject) => {\n      let finished = false\n      /**\n       * Finish.\n       * @param {object} options - Options.\n       * @param {boolean} [options.destroy] - Destroy the socket instead of gracefully closing it.\n       * @param {() => void} callback - Finish callback.\n       */\n      const finish = ({destroy = false} = {}, callback) => {\n        if (finished) return\n        finished = true\n        if (signal) signal.removeEventListener(\"abort\", onAbort)\n        jsonSocket.removeAllListeners()\n\n        if (destroy) {\n          jsonSocket.destroy()\n        } else {\n          jsonSocket.close()\n        }\n\n        callback()\n      }\n\n      /**\n       * Handles a cooperative abort: tears down the pending socket and rejects\n       * with the signal reason when it is an Error.\n       * @returns {void}\n       */\n      const onAbort = () => {\n        const reason = signal?.reason\n\n        finish({destroy: true}, () => reject(reason instanceof Error ? reason : new Error(\"Background job socket request aborted\")))\n      }\n\n      if (signal) {\n        if (signal.aborted) {\n          onAbort()\n          return\n        }\n\n        signal.addEventListener(\"abort\", onAbort)\n      }\n\n      jsonSocket.on(\"error\", (error) => {\n        finish({}, () => reject(error))\n      })\n\n      /**\n       * Handles the socket response message.\n       * @param {import(\"./types.js\").BackgroundJobSocketMessage} message - Socket message.\n       */\n      jsonSocket.on(\"message\", (message) => {\n        onMessage({\n          message,\n          resolve: (value) => finish({}, () => resolve(value)),\n          reject: (error) => finish({}, () => reject(error))\n        })\n      })\n\n      socket.on(\"connect\", () => {\n        jsonSocket.send({type: \"hello\", role: this.role})\n        onConnect(jsonSocket)\n      })\n    })\n  }\n}\n"]}