velocious 1.0.653 → 1.0.655

package/src/http-server/client/index.js

@@ -8,7 +8,7 @@ import EventEmitter from "../../utils/event-emitter.js"
 import Logger from "../../logger.js"
 import Request from "./request.js"
 import RequestRunner from "./request-runner.js"
-import {applyResponseCompression} from "./response-compression.js"
+import {addAcceptEncodingToVary, applyResponseCompression, negotiateContentEncoding} from "./response-compression.js"
 import WebsocketSession from "./websocket-session.js"
 
 /**
@@ -384,7 +384,15 @@ export default class VeoliciousHttpServerClient {
   }
 
   /**
-   * Runs send response.
+   * Sends a finished response to the client. Owns the framework-owned
+   * `Vary: Accept-Encoding` dimension (emitted for every selected
+   * representation — transformed, identity, 406, and file — and for
+   * header-present and header-absent requests alike, so it is stable across
+   * requests on the same connection; never added when compression is disabled,
+   * the response is truly bodyless, or the application supplied a fixed
+   * `Content-Encoding`) and the file 406 rule (a sendFile response whose
+   * client forbids identity is answered with the empty 406, the file is never
+   * opened or streamed, and `onFinished` settles once as "completed").
    * @param {RequestRunner} requestRunner - Request runner.
    * @returns {Promise<void>} - Resolves when complete.
    */
@@ -436,12 +444,41 @@ export default class VeoliciousHttpServerClient {
     /** @type {string | Uint8Array | null} */
     let bodyToEmit = body
 
+    // The response representation can depend on the client's Accept-Encoding:
+    // the same request is answered with an identity body (or a file) when
+    // identity is acceptable and with an empty 406 when it is forbidden.
+    const compression = this.configuration.getHttpServerCompression()
+    const negotiated = compression.enabled ? negotiateContentEncoding(request.header("accept-encoding")) : undefined
+    // An application-supplied Content-Encoding is an application-owned
+    // representation contract, captured before the framework may add its own.
+    // A file carrying one is a fixed, application-owned representation: the
+    // framework neither negotiates it nor re-advertises it, so it is never a
+    // candidate for the identity-only 406.
+    const hasApplicationContentEncoding = response.getHeader("Content-Encoding").length > 0
+    // A file response only ever serves the identity representation: whenever
+    // the client forbids identity (including the not-acceptable case where no
+    // coding applies) and the file does not carry an application-supplied
+    // Content-Encoding, the file is rejected with the empty 406. A truly
+    // bodyless status selects no representation, so it is never rejected here.
+    const isFileNotAcceptable = hasFilePath && !!negotiated && ("notAcceptable" in negotiated || negotiated.identityAcceptable === false) && hasApplicationContentEncoding === false && !isBodylessStatus
+
     if (!isBodylessStatus) {
       let contentLength
 
       if (hasFilePath) {
-        const stats = await fs.stat(filePath)
-        contentLength = stats.size
+        if (isFileNotAcceptable) {
+          // The client forbids identity and files are only ever sent identity:
+          // answer with the same empty 406 every other representation path
+          // uses. The file is never opened or streamed; onFinished is settled
+          // below, after the committed 406 headers are emitted.
+          response.setStatus(406)
+          response.setBody("")
+          bodyToEmit = ""
+          contentLength = 0
+        } else {
+          const stats = await fs.stat(filePath)
+          contentLength = stats.size
+        }
       } else {
         // String bodies are UTF-8 framed, so the buffered bytes are the UTF-8 encoding;
         // Uint8Array bodies are already the exact wire bytes.
@@ -474,6 +511,18 @@ export default class VeoliciousHttpServerClient {
       response.setHeader("Content-Length", contentLength)
     }
 
+    // Framework-owned Vary dimension: whenever compression is enabled and a
+    // representation was selected, the response depends on Accept-Encoding,
+    // so caches must key on it. Applied identically for every outcome
+    // (transformed, identity, 406, file) and for header-present and
+    // header-absent requests alike, so the header is stable across requests on
+    // the same connection. A truly bodyless response selects no representation
+    // and carries no dimension; an application-supplied Content-Encoding keeps
+    // the representation contract application-owned and is never re-advertised.
+    if (negotiated && !isBodylessStatus && hasApplicationContentEncoding === false) {
+      addAcceptEncodingToVary(response)
+    }
+
     response.setHeader("Date", date.toUTCString())
     response.setHeader("Server", "Velocious")
 
@@ -492,8 +541,21 @@ export default class VeoliciousHttpServerClient {
     this.events.emit("output", headers)
     this.logger.debug(() => ["sendResponse headers emitted", {clientCount: this.clientCount, headersLength: headers.length}])
 
-    if (isBodylessStatus) {
+    // A negotiated file 406 is committed above (status 406, empty body) and its
+    // headers were just emitted: settle onFinished now, so the callback runs
+    // after the response is committed — a slow or app-stopping callback cannot
+    // delay or block delivery of the already-emitted 406. The file is never
+    // opened, streamed, or reported (no file event), and the callback settles
+    // exactly once as "completed".
+    if (isFileNotAcceptable) {
+      this.logger.debug(() => ["sendResponse file body suppressed for 406", {clientCount: this.clientCount, filePath}])
+      await this.runFileOnFinished({filePath, onFinished: fileOnFinished, result: "completed"})
+    } else if (isBodylessStatus) {
       this.logger.debug(() => ["sendResponse body suppressed for no-body status", {clientCount: this.clientCount, statusCode: response.getStatusCode()}])
+      // A bodyless status (1xx/204/304) selects no representation, so no file
+      // body or framework Vary is emitted. The file-ownership path still settles
+      // onFinished exactly once as "completed" (nothing was aborted) — even when
+      // the client forbids identity — preserving the pre-change settlement.
       if (hasFilePath) await this.sendFileOutput(filePath, false, fileOnFinished)
     } else if (isHeadRequest) {
       this.logger.debug(() => ["sendResponse body suppressed for HEAD request", {clientCount: this.clientCount}])

package/src/http-server/client/request-buffer/index.js

@@ -8,6 +8,12 @@ import Logger from "../../../logger.js"
 import ParamsToObject from "../params-to-object.js"
 import querystring from "querystring"
 
+/**
+ * Request header fields whose repeated wire fields combine into one value
+ * (RFC 9110 §5.3) before the server consumes them.
+ * @type {Set<string>} */
+const COMBINING_HEADER_FIELDS = new Set(["accept-encoding"])
+
 /**
  * Runs truncate preview.
  * @param {string | undefined} input - Input string.
@@ -367,8 +373,16 @@ export default class RequestBuffer {
    */
   addHeader(header) {
     const formattedName = header.getFormattedName()
+    const existingHeader = this.headersByName[formattedName]
 
-    this.headersByName[formattedName] = header
+    // RFC 9110 §5.3: a field may be repeated; its value is the concatenation of
+    // all field values separated by commas, in wire order. Only Accept-Encoding
+    // is consumed as a combined field by the server.
+    if (existingHeader && COMBINING_HEADER_FIELDS.has(formattedName)) {
+      existingHeader.value += `, ${header.getValue()}`
+    } else {
+      this.headersByName[formattedName] = header
+    }
 
     if (formattedName == "content-length") this.contentLength = parseInt(header.getValue())
   }

package/src/http-server/client/response-compression.js

@@ -22,9 +22,9 @@ const COMPRESSIBLE_EXACT_MEDIA_TYPES = new Set([
 
 /**
  * RFC 9110 §12.4.2 qvalue grammar: `0` or `1` with at most three fractional
- * digits, and only zeros after `1`.
+ * digits (the boundary forms `0.` and `1.` are valid), and only zeros after `1`.
  * @type {RegExp} */
-const QVALUE_PATTERN = /^(?:0(?:\.\d{1,3})?|1(?:\.0{1,3})?)$/u
+const QVALUE_PATTERN = /^(?:0(?:\.\d{0,3})?|1(?:\.0{0,3})?)$/u
 
 /**
  * Runs parse accept encoding.
@@ -118,7 +118,9 @@ export function isCompressibleContentType(contentType) {
 /**
  * Merges Accept-Encoding into the response Vary header case-insensitively and
  * without duplicates. An existing `Vary: *` already covers every request header
- * and is preserved as-is.
+ * and is preserved as-is. Called by the response sender for every
+ * framework-selected representation so the header is identical for every
+ * request on the same connection.
  * @param {import("./response.js").default} response - Response instance.
  * @returns {void} - No return value.
  */
@@ -160,7 +162,7 @@ export function addAcceptEncodingToVary(response) {
  * @param {import("../../configuration-types.js").NormalizedHttpCompressionConfiguration} args.compression - Normalized compression configuration.
  * @param {import("./request.js").default | import("./websocket-request.js").default} args.request - Request object.
  * @param {import("./response.js").default} args.response - Response instance.
- * @returns {Promise<{outcome: "identity"} | {outcome: "compressed", body: Buffer} | {outcome: "not-acceptable"}>} - Compression outcome.
+ * @returns {Promise<{outcome: "identity"} | {outcome: "compressed", body: Buffer} | {outcome: "not-acceptable"}>} - Compression outcome. The caller owns the Vary header and the file/406 representation decisions.
  */
 export async function applyResponseCompression({bodyBuffer, compression, request, response}) {
   if (!compression.enabled) return {outcome: "identity"}
@@ -203,10 +205,6 @@ export async function applyResponseCompression({bodyBuffer, compression, request
     return negotiated.identityAcceptable ? {outcome: "identity"} : {outcome: "not-acceptable"}
   }
 
-  // The representation now depends on the request's Accept-Encoding, even when this
-  // particular response ends up identity (missing header, higher-q identity, below threshold).
-  addAcceptEncodingToVary(response)
-
   if (negotiated.encoding == "identity") return {outcome: "identity"}
 
   // Below the threshold the smaller identity representation is sent instead — but only

package/src/testing/test-runner.js

@@ -142,6 +142,8 @@ import VelociousTestArguments from "./velocious-test-arguments.js"
  * @property {import("../database/pool/base.js").TestSharedConnectionRegistration | undefined} sharedRegistration - Physical-key shared registration once published.
  */
 
+const testingPackageDirectory = path.dirname(fileURLToPath(import.meta.resolve("@velocious/testing/package.json")))
+
 /**
  * Runs to file slug.
  * @param {string} value - Value to sanitize.
@@ -197,6 +199,8 @@ export default class TestRunner {
     this._successfulTests = 0
     this._testsCount = 0
     this._failedTestDetails = []
+    /** @type {import("@velocious/testing/runner").NonRunTestResult[]} */
+    this._notRunTestDetails = []
     /** @type {{fullDescription: string, filePath: string, line: number} | null} */
     this._lastTestContext = null
     /** @type {Array<{fullDescription: string, filePath: string, line: number, durationMs: number}>} */
@@ -1007,6 +1011,25 @@ export default class TestRunner {
     return this._failedTests
   }
 
+  /**
+   * Counts selected tests blocked by a terminal resource.
+   * @returns {number} - Selected tests not executed because a shared resource failed.
+   */
+  getNotRunTests() { return this._notRunTestDetails.length }
+
+  /**
+   * Returns runtime non-run attribution.
+   * @returns {import("@velocious/testing/runner").NonRunTestResult[]} - Runtime non-run details with the originating failure.
+   */
+  getNotRunTestDetails() { return this._notRunTestDetails }
+
+  /**
+   * Records a selected test that did not execute.
+   * @param {import("@velocious/testing/runner").NonRunTestResult} result - Terminal-resource non-run record.
+   * @returns {void}
+   */
+  recordNotRunTest(result) { this._notRunTestDetails.push(result) }
+
   /**
    * Runs get failed test details.
    * @returns {FailedTestDetail[]} - Failed test details.
@@ -1087,6 +1110,14 @@ export default class TestRunner {
     return this._packageResult?.tests.length ?? this._testDurations.length
   }
 
+  /**
+   * Distinguishes an empty selection from a failure before selected cases execute.
+   * @returns {boolean} - Whether selection matched no declarations.
+   */
+  hasNoMatches() {
+    return this._packageResult?.noMatches === true
+  }
+
   /**
    * Returns the tests recorded during the run, slowest first.
    * @param {number} [limit] - Maximum number of tests to return (0 returns all).
@@ -1105,6 +1136,7 @@ export default class TestRunner {
   async prepare() {
     this.anyTestsFocussed = false
     this._failedTests = 0
+    this._notRunTestDetails = []
     this._successfulTests = 0
     this._testsCount = 0
     this._abortRemainingTests = false
@@ -1177,7 +1209,7 @@ export default class TestRunner {
 
       if (portablePath.endsWith("/src/testing/test-runner.js")) continue
       if (portablePath.endsWith("/src/testing/test.js")) continue
-      if (portablePath.includes("/node_modules/@velocious/testing/")) continue
+      if (resolvedFilePath.startsWith(`${testingPackageDirectory}${path.sep}`)) continue
 
       return {filePath: resolvedFilePath, line: Number(match[2])}
     }

package/src/testing/velocious-runner-reporter.js

@@ -1,7 +1,6 @@
 // @ts-check
 
 import { addTrackedStackToError } from "../utils/with-tracked-stack.js"
-import BacktraceCleaner from "../utils/backtrace-cleaner-node.js"
 import picocolors from "picocolors"
 import restArgsError from "../utils/rest-args-error.js"
 import { testEvents } from "./test.js"
@@ -21,6 +20,8 @@ function errorFromPackageRecord(errorRecord) {
 
   error.name = errorRecord.name
   if (errorRecord.stack) error.stack = errorRecord.stack
+  if (errorRecord.cause) error.cause = errorFromPackageRecord(errorRecord.cause)
+  if (errorRecord.terminalResource) Object.assign(error, {terminalResource: errorRecord.terminalResource})
 
   return error
 }
@@ -68,7 +69,27 @@ export default class VelociousRunnerReporter {
       return
     }
 
-    if (event.type === "run:finish") this.testRunner.recordPackageResult(event.result)
+    if (event.type === "test:not-run") {
+      const test = this.testRunner.findTestDeclaration(event.test.fullName)
+      if (!test) throw new Error(`Package not-run result did not match a declaration: ${event.test.fullName}`)
+      this.testRunner.recordNotRunTest(event.test)
+      this.testRunner.completeTestDeclaration(test)
+      console.error(`Not run: ${event.test.fullName} (terminal resource failure in ${event.test.reason.fullName})`)
+      await this.emitEvent("testNotRun", {
+        configuration: this.testRunner.getConfiguration(),
+        test: event.test,
+        testRunner: this.testRunner
+      })
+      return
+    }
+
+    if (event.type === "run:finish") {
+      this.testRunner.recordPackageResult(event.result)
+      for (const failure of event.result.errors) {
+        console.error(`Suite ${failure.phase} failed: ${failure.suite}`)
+        this.printErrorCauses(errorFromPackageRecord(failure.error))
+      }
+    }
   }
 
   /**
@@ -95,7 +116,7 @@ export default class VelociousRunnerReporter {
     const failed = outcome?.failed ?? Boolean(attempt.error)
     const error = outcome?.error
     const retriesUsed = Math.min(attempt.attemptNumber, retryCount)
-    const willRetry = failed && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
+    const willRetry = failed && !event.terminalFailure && !outcome?.abortRemainingTests && attempt.attemptNumber <= retryCount
     const {descriptions, testDescription} = this.testRunner.testMetadata(test)
     const compatibility = this.testRunner.testData(test)
 
@@ -245,15 +266,8 @@ export default class VelociousRunnerReporter {
 
     if (error instanceof Error) {
       console.error(picocolors.red(`${leftPadding}  Test failed: ${error.message}`))
-      addTrackedStackToError(error)
-
-      const backtraceCleaner = new BacktraceCleaner(error)
-      const cleanedStack = backtraceCleaner.getCleanedStack()
-      const stackLines = cleanedStack?.split("\n")
+      this.printErrorCauses(error)
 
-      if (stackLines) {
-        for (const stackLine of stackLines) console.error(picocolors.red(`${leftPadding}  ${stackLine}`))
-      }
     } else {
       console.error(picocolors.red(`${leftPadding}  Test failed with a ${typeof error}: ${String(error)}`))
     }
@@ -274,6 +288,33 @@ export default class VelociousRunnerReporter {
     testRunner.printRerunCommand({descriptions, testDescription, testData, leftPadding})
   }
 
+  /**
+   * Prints complete primary and secondary stacks once, including cyclic cause graphs.
+   * @param {unknown} error - Thrown value at the reporting boundary.
+   * @param {Set<Error>} [reported] - Error identities already printed.
+   * @returns {void}
+   */
+  printErrorCauses(error, reported = new Set()) {
+    if (!(error instanceof Error)) {
+      console.error(String(error))
+      return
+    }
+    if (reported.has(error)) return
+    reported.add(error)
+    addTrackedStackToError(error)
+    console.error(error.stack || `${error.name}: ${error.message}`)
+    if (error.cause !== undefined) {
+      console.error("Caused by:")
+      this.printErrorCauses(error.cause, reported)
+    }
+    if (error instanceof AggregateError) {
+      for (const secondary of error.errors) {
+        console.error("Related failure:")
+        this.printErrorCauses(secondary, reported)
+      }
+    }
+  }
+
   /**
    * Emits one legacy event and awaits listeners in registration order.
    * @param {string} eventName - Event name.