@cosyte/bench 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.4
+
+### Patch Changes
+
+- c854d59: `@cosyte/script-utils`: the attw gate (`cosyte-attw`, `runAttwGate` and `runAttwCli`) now starts on
+  Windows. It used to check `node_modules/.bin/attw` and start it without a shell; on Windows that file
+  is a POSIX shell script, so the start failed with ENOENT, and npm and pnpm, which the gate also
+  starts, are `.cmd` files there that Node will not start without a shell. On Windows the gate now
+  checks and starts `node_modules/.bin/attw.cmd`, and starts all three tools through `cmd.exe` with
+  every argument and every path on the command line in double quotes, a trailing run of backslashes
+  doubled so each argument arrives whole. Elsewhere nothing changes. Two new exports,
+  `attwBinaryPath(callerUrl, platform?)` and `toolCommand(file, args, platform?)`, say which binary and
+  which command line. The gate now refuses an argument carrying a double quote, a percent sign or a
+  line break, on every system: no argument it accepts needs one. A repository that skipped the attw
+  step on Windows can drop the skip once it takes this version. Callers change nothing.
+
+  `@cosyte/bench`: the README now says what the small-input memory budget gives up: a cost in fewer
+  than half of a small case's 20 calls is not bounded, the rule switches at a hard 64 KiB edge, and
+  the empty-call floor's highest call is not a fixed figure (usually about 29 KiB, once 369,888
+  bytes) while its median is stable at about 3.4 KiB. No behavior changes.
+
 ## 0.1.3
 
 ### Patch Changes

package/README.md

@@ -165,17 +165,32 @@ through the same probe (`memoryFloor`), and gives each peak figure both raw and
 median, never below zero (`peakTotalAboveFloorBytes`, `medianPeakTotalAboveFloorBytes`, and the same
 for the heap and external memory).
 
-On a GitHub-hosted runner the floor's median call is about 3.3 KiB and its highest about 28 KiB (one
-call, the first). That highest call is the probe's, and it lands in a case's highest peak too, which
-is why a few hundred bytes of input could not read under 20 times its size whatever the code did.
+On a GitHub-hosted runner the floor's median call is stable, about 3.4 KiB. Its highest call is not:
+usually about 29 KiB (one call, the first), and once 369,888 bytes. That highest call is the
+probe's, and it lands in a case's highest peak too, which is why a few hundred bytes of input could
+not read under 20 times its size whatever the code did. Read the floor's median as the probe's cost;
+its highest is not a fixed figure.
 
 A memory budget reads `budgetPeakBytes(caseReading)`: for a case whose inputs average under
 `BENCH_CONTRACT.FLOOR_INPUT_BYTES` (64 KiB) it is the median call's total above the floor's median,
 the code's typical call without the probe; for any other case, or one whose suite gave no byte
-count, it is the highest raw `peakTotalBytes`. At 64 KiB even the probe's highest call is about 2%
-of a 20 times budget, so a large input keeps the raw highest figure, which needs nothing from
+count, it is the highest raw `peakTotalBytes`. At 64 KiB the probe's usual highest call is about
+2% of a 20 times budget, so a large input keeps the raw highest figure, which needs nothing from
 another process. A suite that added its own empty "floor" case can drop it.
 
+What the rule gives up:
+
+- **A cost in fewer than half the calls is not bounded.** Under 64 KiB the budget reads the median
+  of the case's 20 calls, so a cost that shows in fewer than half of them does not move it. In one
+  reading a small case's highest call was 292,784 bytes against a median of 38,672: the budget read
+  the median. The highest raw peak is still in the reading (`peakTotalBytes`) for anyone who looks.
+- **The switch is a hard edge at 64 KiB.** A case whose inputs average 64 KiB or more reads its
+  highest raw total, and one a byte under reads its median call above the floor. Two sizes either
+  side of the edge can therefore read very different budgets for the same code.
+- **The 2% is the usual highest, not every highest.** The one 369,888-byte floor call is about 28%
+  of a 20 times budget at 64 KiB, so a large case whose highest call lands on such a probe outlier
+  reads it as the code's.
+
 ### Large cases
 
 A case whose single call takes longer than a warmup batch (50 ms) cannot settle by the scaling

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosyte/bench",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Benchmarks for the @cosyte/* packages: throughput, latency percentiles, memory, cold import time and loaded bytes, as versioned JSON, and a base against head comparison interleaved on one machine.",
   "keywords": [
     "benchmark",
@@ -57,11 +57,11 @@
     "tsup": "9.0.0",
     "typescript": "5.9.3",
     "vitest": "5.1.0",
-    "@cosyte/test-utils": "^0.1.4",
+    "@cosyte/eslint-config": "^0.1.4",
     "@cosyte/prettier-config": "^0.1.2",
+    "@cosyte/test-utils": "^0.1.4",
     "@cosyte/tsconfig": "^0.1.2",
-    "@cosyte/tsup-config": "^0.1.3",
-    "@cosyte/eslint-config": "^0.1.4"
+    "@cosyte/tsup-config": "^0.1.3"
   },
   "scripts": {
     "build": "tsup",