@geonosis/ratchet 2.5.3 → 2.6.1

package/CHANGELOG.md

@@ -1,5 +1,53 @@
 # @geonosis/ratchet
 
+## 2.6.1
+
+### Patch Changes
+
+- e1db50f: `geonosis-ratchet` reads `geonosis.ratchet.json` BEFORE it queues for a heavy slot. The slot
+  directory is machine-wide — it bounds heavy work on the box, not per repo — so a second repo's
+  `geonosis-verify` holds it legitimately, and a run with nothing to count was spending the resource
+  that bounds heavy work in order to discover it had no heavy work, waiting `GEONOSIS_HEAVY_WAIT_MS`
+  (20 minutes by default) to then exit 2. Measured 2026-09-07: with during.day's verify holding the
+  only slot on a memory-clamped one-slot box, this kit's own
+  `registry.test.ts > passes the child bin exit code through verbatim` — which spawns a ratchet into a
+  config-less directory expecting an instant refusal — sat for 979,800 ms against a 60,000 ms timeout,
+  three runs running. It now refuses in about a second with every slot held, and a bin case holds it
+  there: a config-less run must name `geonosis.ratchet.json` and must never say it is waiting.
+- db89b0b: Two Stop-hook defects, both caught by making the instrument go red once. A heavy slot is inherited down a process tree: the holder marks its environment with the slot's path, and a descendant whose mark names a living ancestor's slot takes none of its own — a ratchet inside a verify waited on the slot its parent held, for ever, on a one-slot runner (CI's), and now waits on nobody; a tool that takes twice in one process still gets two. The Stop hook judges a run over a dirty tree: a tree's identity is HEAD plus every change on it, the hook's own files aside; a run launched over that identity is read at the next turn end and not re-run while the tree stands, where before an uncommitted edit meant every turn end launched the tier again and none was judged. The kit's own fast tier now builds first, so the hook never judges bins whose `dist` is older than the `src` under test.
+
+## 2.6.0
+
+### Minor Changes
+
+- 58565d7: Plan 029, the factory floor: the gate learns to run things at once, and the heavy budget stops
+  being one laptop's number.
+  
+  `@geonosis/verify` — `TierStep` carries `group`, the number that says which steps run at once, so a
+  tier can declare `{ "parallel": [ … ] }` groups and `{ "command": "… {workspace} …", "per":
+  "workspace" }` steps. New: `affected.ts` (`affected`, `affectedOf`, `workspacesIn`, `changedSince`,
+  `mergeBase`, `ROOT_SHAPED`, types `Affected` and `Workspace`), `PerWorkspace`, `ParallelStep`,
+  `CommandStep` on `config`, and `planSteps`, `runGroups`, `shellRunAsync`, `PlannedStep`,
+  `AsyncStepRun` on `run`. `GateReport` gains an optional `affected` block. `runSteps`, `shellRun` and
+  `stepIds` are unchanged. The bin gains `--affected`, `--since <ref>` and `--jobs <n>`.
+  
+  `@geonosis/ratchet` and `@geonosis/release` — `heavySlots()` and `DEFAULT_HEAVY_SLOTS` beside
+  `HEAVY_SLOTS`, which is no longer the constant 2: the budget is `GEONOSIS_HEAVY_SLOTS` or
+  `availableParallelism() - 1`, read on every claim rather than at module load (D-073).
+  
+  `@geonosis/ledger` — `shape.ts`: `shapeCheck`, `readManifest`, `exportsOf`, `formatShape` and the
+  types `BriefManifest`, `ShapeRefusal`, `ShapeOutcome` — the lock that refuses an engineer diff
+  touching a locked test, renaming an export or adding a file the brief did not name (D-072). Not yet
+  on the package's public entry: the CLI door lands with W115's dispatch unit.
+  
+  `geonosis` — the plugin's post-edit hook takes its formatter from `geonosis.json → stack.format`
+  (D-070) and the stop hook reads the machine's heavy budget.
+- 58565d7: The heavy budget is memory-aware (D-081, amending D-073). `heavyBudget()` — on `@geonosis/ratchet`'s door, copied into `@geonosis/release` and the plugin's Stop hook and held to one answer by a test — is the smaller of one less than the cores and the memory the machine can spend divided by what one run holds: `geonosis.json → stack.memoryMbPerSlot`, 512 MB when nothing is declared. `GEONOSIS_HEAVY_SLOTS` still wins outright; `GEONOSIS_HEAVY_MEMORY_MB` is the memory to spend instead of the machine's. `heavySlots()` is the budget's number read fresh, and `describeBudget()` names the number and both inputs. `geonosis-verify --jobs` defaults to it, its report carries it as `heavy`, and the run prints it; the kit's own vitest workers read it too. Measured on a 4-core, 3.4 GB box: three slots over 1.4 GB swapped; two do not.
+
+### Patch Changes
+
+- 58565d7: The oxlint counters read the graphical format's Unicode markers — `×` for an error, `⚠` for a warning — beside the ASCII `x` and `!` a pipe gets. CI's terminal printed the Unicode pair, `oxlintRule` saw two findings it could attribute to no rule, and refused as its contract says; a laptop's vitest child never printed them.
+
 ## 2.5.3
 
 ## 2.5.2

package/dist/{chunk-WENVCC67.js → chunk-GJD2676B.js}

@@ -1,6 +1,51 @@
+// src/core/config.ts
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+var CONFIG_FILE = "geonosis.ratchet.json";
+var keyOf = (entry) => entry.key ?? entry.counter;
+var loadConfig = (cwd) => {
+  const path = resolve(cwd, CONFIG_FILE);
+  if (!existsSync(path)) {
+    throw new Error(`no ${CONFIG_FILE} in ${cwd} \u2014 the ratchet has nothing to count`);
+  }
+  const parsed = JSON.parse(readFileSync(path, "utf8"));
+  if (!Array.isArray(parsed.counters)) {
+    throw new Error(`${CONFIG_FILE} has no "counters" array`);
+  }
+  for (const entry of parsed.counters) {
+    if (typeof entry.counter !== "string") {
+      throw new Error(`${CONFIG_FILE}: every counter entry needs a "counter" id`);
+    }
+    if (entry.tiers !== void 0) {
+      const named = Array.isArray(entry.tiers) && entry.tiers.length > 0 && entry.tiers.every((tier) => typeof tier === "string" && tier.length > 0);
+      if (!named) {
+        throw new Error(
+          `${CONFIG_FILE}: "${keyOf(entry)}" has "tiers" that is not a non-empty list of tier names`
+        );
+      }
+    }
+  }
+  const keys = parsed.counters.map(keyOf);
+  const duplicate = keys.find((key, at) => keys.indexOf(key) !== at);
+  if (duplicate !== void 0) {
+    throw new Error(
+      `${CONFIG_FILE}: two counters both write "${duplicate}" \u2014 give one of them a distinct "key"`
+    );
+  }
+  return { baseline: parsed.baseline ?? "gate-baseline.json", counters: parsed.counters };
+};
+var resolveBaseline = (cwd) => {
+  try {
+    const parsed = JSON.parse(readFileSync(resolve(cwd, CONFIG_FILE), "utf8"));
+    return typeof parsed.baseline === "string" ? parsed.baseline : "gate-baseline.json";
+  } catch {
+    return "gate-baseline.json";
+  }
+};
+
 // src/core/envelope.ts
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { dirname, join, resolve } from "path";
+import { mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { dirname, join, resolve as resolve2 } from "path";
 import { fileURLToPath } from "url";
 var ENVELOPES_DIR = ".geonosis/envelopes";
 var envelopePath = (root, tool) => join(root, ENVELOPES_DIR, `${tool}.json`);
@@ -15,7 +60,7 @@ var unbalancedMessage = (envelope, next) => `${envelope.tool}: considered ${enve
 var FORBIDDEN_ROOT = "GEONOSIS_ENVELOPES_FORBIDDEN_ROOT";
 var refuseForbiddenRoot = (root) => {
   const forbidden = process.env[FORBIDDEN_ROOT];
-  if (forbidden === void 0 || resolve(forbidden) !== resolve(root)) return;
+  if (forbidden === void 0 || resolve2(forbidden) !== resolve2(root)) return;
   throw new UnbalancedEnvelope(
     `${root} is off limits to envelope writers in this process (${FORBIDDEN_ROOT}) \u2014 a run that writes one into a shared root races every other run reading it, and leaves a file the next one takes for real. Point this at a scratch root of its own: tooling/scratch-dir.ts.`
   );
@@ -53,7 +98,7 @@ var writeEnvelope = ({
 var UNKNOWN = "unknown";
 var versionIn = (dir) => {
   try {
-    const manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+    const manifest = JSON.parse(readFileSync2(join(dir, "package.json"), "utf8"));
     return typeof manifest.version === "string" ? manifest.version : void 0;
   } catch {
     return void 0;
@@ -71,8 +116,8 @@ var versionOf = (moduleUrl) => {
 };
 
 // src/core/heavy-slot.ts
-import { readFileSync as readFileSync2, rmSync as rmSync2 } from "fs";
-import { tmpdir } from "os";
+import { readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { availableParallelism, freemem, tmpdir } from "os";
 import { join as join2 } from "path";
 
 // src/core/file-claim.ts
@@ -104,7 +149,42 @@ var claimFile = (path, holder) => {
 };
 
 // src/core/heavy-slot.ts
-var HEAVY_SLOTS = 2;
+var availableMemoryMb = () => {
+  try {
+    const found = /^MemAvailable:\s+(\d+) kB/m.exec(readFileSync3("/proc/meminfo", "utf8"));
+    if (found?.[1] !== void 0) return Math.floor(Number(found[1]) / 1024);
+  } catch {
+  }
+  return Math.floor(freemem() / 1048576);
+};
+var DEFAULT_MEMORY_MB_PER_SLOT = 512;
+var DEFAULT_HEAVY_SLOTS = Math.max(1, availableParallelism() - 1);
+var perSlotMbDeclaredIn = (root) => {
+  try {
+    const parsed = JSON.parse(readFileSync3(join2(root, "geonosis.json"), "utf8"));
+    const declared = parsed.stack?.memoryMbPerSlot;
+    return typeof declared === "number" && Number.isFinite(declared) && declared > 0 ? declared : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var heavyBudget = (input = {}) => {
+  const declared = Number(process.env.GEONOSIS_HEAVY_SLOTS ?? "");
+  const spendable = Number(process.env.GEONOSIS_HEAVY_MEMORY_MB ?? "");
+  const reading = {
+    availableMemoryMb: input.availableMemoryMb ?? (Number.isFinite(spendable) && spendable > 0 ? spendable : availableMemoryMb()),
+    cores: input.cores ?? availableParallelism(),
+    perSlotMb: input.perSlotMb ?? perSlotMbDeclaredIn(input.root ?? process.cwd()) ?? DEFAULT_MEMORY_MB_PER_SLOT
+  };
+  if (Number.isInteger(declared) && declared > 0)
+    return { ...reading, by: "declared", slots: declared };
+  const byCores = Math.max(1, reading.cores - 1);
+  const byMemory = Math.max(1, Math.floor(reading.availableMemoryMb / reading.perSlotMb));
+  return byMemory < byCores ? { ...reading, by: "memory", slots: byMemory } : { ...reading, by: "cores", slots: byCores };
+};
+var describeBudget = (budget) => `${budget.slots} heavy slot(s), bound by ${budget.by === "declared" ? "GEONOSIS_HEAVY_SLOTS" : budget.by} \u2014 ${budget.cores} cores, ${budget.availableMemoryMb} MB available, ${budget.perSlotMb} MB per slot`;
+var heavySlots = () => heavyBudget().slots;
+var HEAVY_SLOTS = heavySlots();
 var DEFAULT_WAIT_MS = 20 * 6e4;
 var heavySlotDir = () => {
   const named = process.env.GEONOSIS_HEAVY_SLOT_DIR;
@@ -114,7 +194,7 @@ var heavySlotDir = () => {
 var slotPath = (dir, at) => join2(dir, `slot-${at}.json`);
 var holderOf = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
+    const parsed = JSON.parse(readFileSync3(path, "utf8"));
     return typeof parsed.pid === "number" ? {
       command: parsed.command ?? "unknown",
       cwd: parsed.cwd ?? "somewhere",
@@ -130,12 +210,19 @@ var reapIfDead = (path) => {
   if (holder !== void 0 && !alive(holder.pid)) rmSync2(path, { force: true });
 };
 var claim = (path, holder) => claimFile(path, holder);
-var namedHolders = (dir) => Array.from({ length: HEAVY_SLOTS }, (_unused, at) => holderOf(slotPath(dir, at))).filter(
+var namedHolders = (dir) => Array.from({ length: heavySlots() }, (_unused, at) => holderOf(slotPath(dir, at))).filter(
   (holder) => holder !== void 0
 );
 var describeHolders = (holders) => holders.map((one) => `${one.pid} ${one.command} since ${one.startedAt}`).join(", ");
 var HeavySlotTimeout = class extends Error {
 };
+var HEAVY_SLOT_HELD = "GEONOSIS_HEAVY_SLOT_HELD";
+var inherited = () => {
+  const named = process.env[HEAVY_SLOT_HELD];
+  if (named === void 0 || named === "") return false;
+  const holder = holderOf(named);
+  return holder !== void 0 && holder.pid !== process.pid && alive(holder.pid);
+};
 var takeSlot = async ({
   command,
   cwd = process.cwd(),
@@ -145,10 +232,11 @@ var takeSlot = async ({
 `),
   waitMs = Number(process.env.GEONOSIS_HEAVY_WAIT_MS ?? "") || DEFAULT_WAIT_MS
 }) => {
+  if (inherited()) return () => void 0;
   const until = Date.now() + waitMs;
   let told = false;
   for (; ; ) {
-    for (let at = 0; at < HEAVY_SLOTS; at += 1) {
+    for (let at = 0; at < heavySlots(); at += 1) {
       const path = slotPath(dir, at);
       reapIfDead(path);
       const mine = {
@@ -158,8 +246,10 @@ var takeSlot = async ({
         startedAt: (/* @__PURE__ */ new Date()).toISOString()
       };
       if (claim(path, mine)) {
+        process.env[HEAVY_SLOT_HELD] = path;
         return () => {
           if (holderOf(path)?.pid === process.pid) rmSync2(path, { force: true });
+          if (process.env[HEAVY_SLOT_HELD] === path) delete process.env[HEAVY_SLOT_HELD];
         };
       }
     }
@@ -178,7 +268,7 @@ var takeSlot = async ({
 };
 
 // src/core/lock.ts
-import { readFileSync as readFileSync3, rmSync as rmSync3 } from "fs";
+import { readFileSync as readFileSync4, rmSync as rmSync3 } from "fs";
 import { homedir } from "os";
 import { isAbsolute, join as join3 } from "path";
 var heavyLockPath = () => {
@@ -190,7 +280,7 @@ var heavyLockPath = () => {
 };
 var holderOf2 = (path) => {
   try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
+    const parsed = JSON.parse(readFileSync4(path, "utf8"));
     return typeof parsed.pid === "number" ? {
       cwd: parsed.cwd ?? "somewhere",
       pid: parsed.pid,
@@ -245,51 +335,6 @@ var acquireExclusive = async ({
   }
 };
 
-// src/core/config.ts
-import { existsSync, readFileSync as readFileSync4 } from "fs";
-import { resolve as resolve2 } from "path";
-var CONFIG_FILE = "geonosis.ratchet.json";
-var keyOf = (entry) => entry.key ?? entry.counter;
-var loadConfig = (cwd) => {
-  const path = resolve2(cwd, CONFIG_FILE);
-  if (!existsSync(path)) {
-    throw new Error(`no ${CONFIG_FILE} in ${cwd} \u2014 the ratchet has nothing to count`);
-  }
-  const parsed = JSON.parse(readFileSync4(path, "utf8"));
-  if (!Array.isArray(parsed.counters)) {
-    throw new Error(`${CONFIG_FILE} has no "counters" array`);
-  }
-  for (const entry of parsed.counters) {
-    if (typeof entry.counter !== "string") {
-      throw new Error(`${CONFIG_FILE}: every counter entry needs a "counter" id`);
-    }
-    if (entry.tiers !== void 0) {
-      const named = Array.isArray(entry.tiers) && entry.tiers.length > 0 && entry.tiers.every((tier) => typeof tier === "string" && tier.length > 0);
-      if (!named) {
-        throw new Error(
-          `${CONFIG_FILE}: "${keyOf(entry)}" has "tiers" that is not a non-empty list of tier names`
-        );
-      }
-    }
-  }
-  const keys = parsed.counters.map(keyOf);
-  const duplicate = keys.find((key, at) => keys.indexOf(key) !== at);
-  if (duplicate !== void 0) {
-    throw new Error(
-      `${CONFIG_FILE}: two counters both write "${duplicate}" \u2014 give one of them a distinct "key"`
-    );
-  }
-  return { baseline: parsed.baseline ?? "gate-baseline.json", counters: parsed.counters };
-};
-var resolveBaseline = (cwd) => {
-  try {
-    const parsed = JSON.parse(readFileSync4(resolve2(cwd, CONFIG_FILE), "utf8"));
-    return typeof parsed.baseline === "string" ? parsed.baseline : "gate-baseline.json";
-  } catch {
-    return "gate-baseline.json";
-  }
-};
-
 // src/core/types.ts
 var CounterError = class extends Error {
   constructor(counter, message) {
@@ -1168,13 +1213,15 @@ var UNIX_FINDING = /^\S[^\n]*:\d+:\d+: .*\[(Error|Warning)\/[^\]\n]+\]$/gm;
 var UNIX_SUMMARY = /^(\d+) problems?$/m;
 var AGENT_FINDING = /^\S[^\n]*:\d+:\d+: (error|warning) /gm;
 var DEFAULT_SUMMARY = /^Found (\d+) warnings? and (\d+) errors?\.$/m;
-var DEFAULT_FINDING = /^\s*([x!]) [^\s(]+\([^)\n]+\): /m;
+var DEFAULT_FINDING = /^\s*([x!×⚠]) [^\s(]+\([^)\n]+\): /m;
 var FINDING_SHAPES = [UNIX_FINDING, AGENT_FINDING, DEFAULT_FINDING].map(
   (shape) => new RegExp(shape.source)
 );
 var RULE_TOKEN = /\([^()\n]+\)/;
 var SEVERITY_BY_TOKEN = {
   "!": "warning",
+  "\xD7": "error",
+  "\u26A0": "warning",
   Error: "error",
   error: "error",
   Warning: "warning",
@@ -2179,11 +2226,20 @@ var formatProve = ({ proofs, proven }) => {
 };
 
 export {
+  CONFIG_FILE,
+  keyOf,
+  loadConfig,
+  resolveBaseline,
   ENVELOPES_DIR,
   envelopePath,
   UnbalancedEnvelope,
   writeEnvelope,
   versionOf,
+  availableMemoryMb,
+  DEFAULT_MEMORY_MB_PER_SLOT,
+  heavyBudget,
+  describeBudget,
+  heavySlots,
   HEAVY_SLOTS,
   heavySlotDir,
   describeHolders,
@@ -2191,10 +2247,6 @@ export {
   takeSlot,
   heavyLockPath,
   acquireExclusive,
-  CONFIG_FILE,
-  keyOf,
-  loadConfig,
-  resolveBaseline,
   CounterError,
   runCommand,
   runProve,

package/dist/cli.js

@@ -3,12 +3,13 @@ import {
   acquireExclusive,
   formatProve,
   formatReport,
+  loadConfig,
   runProve,
   runRatchet,
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-WENVCC67.js";
+} from "./chunk-GJD2676B.js";
 
 // src/cli.ts
 import process from "process";
@@ -132,6 +133,7 @@ var measure = async () => {
 ` : formatProve(proof));
     return proof.proven ? 0 : 2;
   }
+  loadConfig(cwd);
   releaseHeavySlot = await takeSlot({
     command: `geonosis-ratchet${tier === void 0 ? "" : ` --tier ${tier}`}`,
     cwd

package/dist/index.d.ts

@@ -288,33 +288,44 @@ declare const versionOf: (moduleUrl: string) => string;
 declare const COUNTERS: Counter[];
 declare const counterById: (id: string) => Counter;
 
-/** Who is spending a heavy slot, running what, since when. */
 type HeavySlotHolder = {
     command: string;
     cwd: string;
     pid: number;
     startedAt: string;
 };
+/** The memory the machine can spend now: `MemAvailable` where the kernel says it, `os.freemem()` where it does not. */
+declare const availableMemoryMb: () => number;
+/** What one heavy run is budgeted to hold when the repo declares nothing: a vitest worker measured 334 MB and a tsc 224 MB (plan 030). */
+declare const DEFAULT_MEMORY_MB_PER_SLOT = 512;
+type HeavyBudget = {
+    availableMemoryMb: number;
+    /** What bound the number: a declared `GEONOSIS_HEAVY_SLOTS`, the cores, or the memory. */
+    by: 'cores' | 'declared' | 'memory';
+    cores: number;
+    perSlotMb: number;
+    slots: number;
+};
 /**
- * Two, not one: `core/lock.ts`'s `acquireExclusive` serialises a whole run against every other; this
- * is the machine's OWN ceiling — measured 2026-09-05, load 48 with during.day's Stop-hook tier, this
- * kit's Stop-hook tier, this kit's ratchet and an engineer's suite all running at once. A machine that
- * can carry two heavy things at a time carries two; a third waits.
+ * The heavy budget, read fresh: the smaller of one less than the cores and the memory divided by
+ * what one run holds (D-081, amending D-073). A declared `GEONOSIS_HEAVY_SLOTS` wins over both;
+ * `GEONOSIS_HEAVY_MEMORY_MB` is the memory to spend instead of the machine's; the per-slot number
+ * is `geonosis.json → stack.memoryMbPerSlot`, 512 when nothing is declared.
  */
-declare const HEAVY_SLOTS = 2;
+declare const heavyBudget: (input?: {
+    availableMemoryMb?: number;
+    cores?: number;
+    perSlotMb?: number;
+    root?: string;
+}) => HeavyBudget;
+/** One line a report can carry: the number, and both inputs it was read from. */
+declare const describeBudget: (budget: HeavyBudget) => string;
+declare const heavySlots: () => number;
+declare const HEAVY_SLOTS: number;
 declare const heavySlotDir: () => string;
 declare const describeHolders: (holders: HeavySlotHolder[]) => string;
-/** A wait that ran out. The message names every holder, because the caller's own refusal is this text. */
 declare class HeavySlotTimeout extends Error {
 }
-/**
- * Claims one of the two machine-wide heavy slots, waiting for whoever holds them.
- *
- * A dead holder is reaped before a slot is tried, so a killed run never wedges the budget for
- * whoever asks next. Both held is announced ONCE — not on every poll, which would turn a half-hour
- * wait into a half hour of identical lines — and the wait is bounded, so a taker that can never get
- * in refuses instead of hanging the process that called it.
- */
 declare const takeSlot: ({ command, cwd, dir, pollMs, say, waitMs, }: {
     command: string;
     cwd?: string;
@@ -413,4 +424,4 @@ declare const formatProve: ({ proofs, proven }: ProveResult) => string;
  */
 declare const runCommand: (cwd: string, counterId: string, env?: NodeJS.ProcessEnv) => (command: string) => CommandResult;
 
-export { CONFIG_FILE, COUNTERS, type CommandResult, type Counter, type CounterConfig, type CounterContext, CounterError, type CounterProbe, ENVELOPES_DIR, type EnvelopeEntry, HEAVY_SLOTS, type HeavySlotHolder, HeavySlotTimeout, type Holder, type Measurement, type Proof, type ProveResult, type RatchetConfig, type RatchetResult, type Refusal, type ReportEnvelope, UnbalancedEnvelope, type Verdict, acquireExclusive, counterById, describeHolders, envelopePath, formatProve, formatReport, heavyLockPath, heavySlotDir, keyOf, loadConfig, resolveBaseline, runCommand, runProve, runRatchet, takeSlot, versionOf, writeEnvelope };
+export { CONFIG_FILE, COUNTERS, type CommandResult, type Counter, type CounterConfig, type CounterContext, CounterError, type CounterProbe, DEFAULT_MEMORY_MB_PER_SLOT, ENVELOPES_DIR, type EnvelopeEntry, HEAVY_SLOTS, type HeavyBudget, type HeavySlotHolder, HeavySlotTimeout, type Holder, type Measurement, type Proof, type ProveResult, type RatchetConfig, type RatchetResult, type Refusal, type ReportEnvelope, UnbalancedEnvelope, type Verdict, acquireExclusive, availableMemoryMb, counterById, describeBudget, describeHolders, envelopePath, formatProve, formatReport, heavyBudget, heavyLockPath, heavySlotDir, heavySlots, keyOf, loadConfig, resolveBaseline, runCommand, runProve, runRatchet, takeSlot, versionOf, writeEnvelope };

package/dist/index.js

@@ -2,18 +2,23 @@ import {
   CONFIG_FILE,
   COUNTERS,
   CounterError,
+  DEFAULT_MEMORY_MB_PER_SLOT,
   ENVELOPES_DIR,
   HEAVY_SLOTS,
   HeavySlotTimeout,
   UnbalancedEnvelope,
   acquireExclusive,
+  availableMemoryMb,
   counterById,
+  describeBudget,
   describeHolders,
   envelopePath,
   formatProve,
   formatReport,
+  heavyBudget,
   heavyLockPath,
   heavySlotDir,
+  heavySlots,
   keyOf,
   loadConfig,
   resolveBaseline,
@@ -23,23 +28,28 @@ import {
   takeSlot,
   versionOf,
   writeEnvelope
-} from "./chunk-WENVCC67.js";
+} from "./chunk-GJD2676B.js";
 export {
   CONFIG_FILE,
   COUNTERS,
   CounterError,
+  DEFAULT_MEMORY_MB_PER_SLOT,
   ENVELOPES_DIR,
   HEAVY_SLOTS,
   HeavySlotTimeout,
   UnbalancedEnvelope,
   acquireExclusive,
+  availableMemoryMb,
   counterById,
+  describeBudget,
   describeHolders,
   envelopePath,
   formatProve,
   formatReport,
+  heavyBudget,
   heavyLockPath,
   heavySlotDir,
+  heavySlots,
   keyOf,
   loadConfig,
   resolveBaseline,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geonosis/ratchet",
-  "version": "2.5.3",
+  "version": "2.6.1",
   "types": "./dist/index.d.ts",
   "description": "Debt as a number that may only shrink — one ratchet, pluggable counters.",
   "keywords": [
@@ -43,6 +43,10 @@
   },
   "scripts": {
     "build": "tsup",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint --config ../../.oxlintrc.json .",
+    "test:unit": "vitest run --project unit --root ../.. --passWithNoTests \"$PWD\"",
+    "test:bin": "vitest run --project bin --root ../.. --passWithNoTests \"$PWD\"",
+    "test:exam": "vitest run --project exam --root ../.. --passWithNoTests \"$PWD\""
   }
 }