@vantageos/backend-doctor 0.1.5 → 0.1.6

package/dist/detectors/source/jobs.js

@@ -142,57 +142,128 @@ export function scanR20(files) {
 //
 // SOURCE READ: convex/credentials.ts issues a Bearer under a rate limit of
 // `maxPerWindow: 5` over `windowMs: 60_000` (lines 513-514), rejecting with a
-// `429` (line 523) — numeric rate + numeric window. PATTERN: a file that
-// references a rate-limit control (`rateLimit` / `maxPerWindow` / `windowMs`) is
-// conform iff BOTH a numeric window and a numeric max are present; a rate-limit
-// control whose bounds are only non-numeric placeholders (no numeric literal) is
-// the violation (unless a written exception is on file).
+// `429` (line 523); mcp-server/server-http.ts declares the DCR `/register`
+// limiter as the `REGISTER_RATE_LIMIT = 5` / `REGISTER_RATE_WINDOW_MS = 60_000`
+// const pair (lines 297-298) — numeric rate + numeric window at ONE site.
+//
+// SITE-scoped, not file-scoped. Two defects the old file-wide scan carried:
+//  (1) FALSE POSITIVE — `referencesRate` was true for ANY file containing the
+//      substring `rateLimit`, so the schema TABLE NAME `credentialsRateLimits`
+//      (convex/schema.ts) dragged schema.ts into the scan, and the file-wide
+//      window pattern then matched the unrelated `2000` in
+//      `body: v.string(), // truncated to 2000 chars` (schema.ts:540) — a
+//      phantom R-23 violation on a v.string() field. A schema table declaration
+//      is NOT a rate-limit control, and a numeric elsewhere in the file is not
+//      "this control's window".
+//  (2) FILE→SITE leak — because window/max/exception were found file-wide, ONE
+//      `rate-limit exception:` marker anywhere conformed EVERY control in the
+//      file. The window was never bound to its own max/control.
+//
+// PATTERN: locate each CONTROL SITE (a local region declaring/enforcing a
+// limiter — a `maxPerWindow:` key, a `*_RATE_LIMIT =` numeric const, a
+// `per minute/second/hour` check, or a written-exception marker). A schema
+// `defineTable(...)` block or a validator field (`v.number()`) is NEVER a
+// control site. Each site is judged WITHIN its own local line span: a numeric
+// max AND a numeric window there -> conform; else an exception marker bound to
+// THAT site -> conform; else -> violate. A numeric/exception on a DIFFERENT
+// site does not carry.
 // ---------------------------------------------------------------------------
-const RATE_REF = /ratelimit|maxperwindow|windowms|per\s+(minute|second|hour)/i;
-const NUMERIC_WINDOW = /windowms\s*:\s*\d|(\d[\d_]*)\s*(ms|_?000)\b|per\s+(minute|second|hour)/i;
-const NUMERIC_MAX = /maxperwindow\s*:\s*\d|\b\d+\s*(req|requests|per)\b/i;
+const NUMERIC_WINDOW = /windowms\s*:\s*\d|\brate_?window\w*\s*=\s*\d|(\d[\d_]*)\s*(ms|_?000)\b|per\s+(minute|second|hour)/i;
+const NUMERIC_MAX = /maxperwindow\s*:\s*\d|\brate_?limit\w*\s*=\s*\d|\b\d+\s*(req|requests|per)\b/i;
 const WRITTEN_EXCEPTION = /allow-unbounded|written exception|rate-limit exception/i;
-function referencesRate(f) {
-    return f.lines.some((l) => code(l) && RATE_REF.test(l.raw));
+// A limiter DECLARATION/enforcement, not a mere keyword mention:
+//  - `maxPerWindow:` — the per-window MAX key (the definitive throttle signal;
+//    a lone `windowMs` is only a duration and appears everywhere, so it is
+//    never an anchor by itself — only a window CONFIRMATION inside a site).
+//  - `*_RATE_LIMIT = <numeric>` — the const-pair form (server-http.ts).
+// A `per minute/second/hour` phrase is NOT an anchor: it appears in
+// human-readable rejection strings (`"...5 registrations per minute per IP."`)
+// that are not control declarations. It survives only as a WINDOW confirmation
+// inside a site already anchored by a real limiter declaration.
+const RATE_CONTROL_DECL = /maxperwindow\s*:|\brate_?limit\w*\s*=\s*\d/i;
+// A schema table declaration or a validator field is never a control SITE —
+// this is what excludes `credentialsRateLimits: defineTable(...)` and
+// `maxPerWindow: v.number()` from anchoring a site.
+const SCHEMA_DECL = /definetable\s*\(|v\.\w+\s*\(/i;
+// Local span geometry: consecutive anchors within MERGE_GAP lines collapse into
+// ONE site (a const group / a single call's arg object); the site's judgement
+// window is that anchor run padded by CONTEXT lines each side — never the file.
+const CONTEXT = 3;
+const MERGE_GAP = 3;
+function isControlAnchor(raw) {
+    // An explicit written exception always marks a site, even on an odd line.
+    if (WRITTEN_EXCEPTION.test(raw))
+        return true;
+    // A schema table decl / validator field is never a control site.
+    if (SCHEMA_DECL.test(raw))
+        return false;
+    return RATE_CONTROL_DECL.test(raw);
 }
 export function scanR23(files) {
     const scan = emptyScan();
     for (const f of files) {
-        if (!isJudgeable(f) || !referencesRate(f))
+        if (!isJudgeable(f))
             continue;
-        let windowLine = 0;
-        let maxLine = 0;
-        let exception = 0;
-        for (const l of f.lines) {
-            if (!code(l))
-                continue;
-            if (!windowLine && NUMERIC_WINDOW.test(l.raw))
-                windowLine = l.n;
-            if (!maxLine && NUMERIC_MAX.test(l.raw))
-                maxLine = l.n;
-            if (!exception && WRITTEN_EXCEPTION.test(l.raw))
-                exception = l.n;
-        }
-        if (windowLine && maxLine) {
-            scan.conform.push({
-                rel: f.rel,
-                n: maxLine,
-                note: `rate control declares a numeric max (line ${maxLine}) and window (line ${windowLine})`,
-            });
+        // 1. Collect the code-line indices that anchor a control site.
+        const anchors = [];
+        for (let i = 0; i < f.lines.length; i++) {
+            const l = f.lines[i];
+            if (code(l) && isControlAnchor(l.raw))
+                anchors.push(i);
         }
-        else if (exception) {
-            scan.conform.push({
-                rel: f.rel,
-                n: exception,
-                note: `rate bound absent but a written exception is on file (line ${exception})`,
-            });
+        if (anchors.length === 0)
+            continue;
+        // 2. Merge adjacent anchors (gap <= MERGE_GAP) into one site.
+        const sites = [];
+        for (const idx of anchors) {
+            const open = sites[sites.length - 1];
+            if (open && idx - open.last <= MERGE_GAP) {
+                open.last = idx;
+            }
+            else {
+                sites.push({ first: idx, last: idx });
+            }
         }
-        else {
-            scan.violate.push({
-                rel: f.rel,
-                n: windowLine || maxLine || 1,
-                note: "rate-limit control present but its bound is not numeric (placeholder) and no written exception on file",
-            });
+        // 3. Judge each site WITHIN its own local span — never file-wide.
+        for (const site of sites) {
+            const from = Math.max(0, site.first - CONTEXT);
+            const to = Math.min(f.lines.length - 1, site.last + CONTEXT);
+            let windowLine = 0;
+            let maxLine = 0;
+            let exception = 0;
+            for (let j = from; j <= to; j++) {
+                const l = f.lines[j];
+                if (!code(l))
+                    continue;
+                if (!windowLine && NUMERIC_WINDOW.test(l.raw))
+                    windowLine = l.n;
+                if (!maxLine && NUMERIC_MAX.test(l.raw))
+                    maxLine = l.n;
+                if (!exception && WRITTEN_EXCEPTION.test(l.raw))
+                    exception = l.n;
+            }
+            const repLine = f.lines[site.first].n;
+            if (windowLine && maxLine) {
+                scan.conform.push({
+                    rel: f.rel,
+                    n: maxLine,
+                    note: `rate control site declares a numeric max (line ${maxLine}) and window (line ${windowLine}) bound to the same site`,
+                });
+            }
+            else if (exception) {
+                scan.conform.push({
+                    rel: f.rel,
+                    n: exception,
+                    note: `rate bound absent but a written exception is bound to THIS control site (line ${exception})`,
+                });
+            }
+            else {
+                scan.violate.push({
+                    rel: f.rel,
+                    n: windowLine || maxLine || repLine,
+                    note: "rate-limit control site present but its bound is not numeric (placeholder) and no written exception is bound to this site",
+                });
+            }
         }
     }
     return scan;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vantageos/backend-doctor",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "A conformance instrument that measures the VantagePeers backend against the pinned backend standard. The THIRD doctor built ON the @vantageos/mcp-doctor engine — never a third engine. It consumes runDoctor/renderTable and adds only detectors.",
   "type": "module",
   "main": "./dist/cli.js",