srclawyer 0.5.0 → 0.6.0

package/dist/grammars/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Max Brunsfeld
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/policy/generatePolicy.d.ts

@@ -1,3 +1,3 @@
 import type { ScanResult } from "../engine/types.js";
 import { type SrcLawyerConfig } from "../config/config.js";
-export declare function generatePolicyMarkdown(result: ScanResult, config: SrcLawyerConfig | null, llmError?: string | null): string;
+export declare function generatePolicyMarkdown(result: ScanResult, config: SrcLawyerConfig | null, llmError?: string | null, protectedLogicWarning?: string | null): string;

package/dist/policy/generatePolicy.js

@@ -102,6 +102,12 @@ function renderContextSection(config) {
 function renderUnsupportedStackWarning(warning) {
     return ["> **WARNING: INCOMPLETE SCAN — DO NOT PUBLISH WITHOUT MANUAL REVIEW**", ">", `> ${warning}`].join("\n");
 }
+// Mirrors renderUnsupportedStackWarning's own reasoning exactly: this policy FILE gets committed and
+// shared on its own, without the CLI output that already shows this warning -- a reader of the file
+// alone has no other way to know confidence grading or Zod-schema detection didn't run for this scan.
+function renderProtectedLogicWarning(warning) {
+    return ["> **WARNING: PROTECTED-LOGIC SERVICE UNAVAILABLE — POLICY MAY BE INCOMPLETE**", ">", `> ${warning}`].join("\n");
+}
 function outcomeOf(finding) {
     if (!finding.requiresReview)
         return "confident";
@@ -111,7 +117,7 @@ function outcomeOf(finding) {
         return "declined";
     return "unresolved";
 }
-export function generatePolicyMarkdown(result, config, llmError) {
+export function generatePolicyMarkdown(result, config, llmError, protectedLogicWarning) {
     const confidentFindings = result.findings.filter((f) => {
         const outcome = outcomeOf(f);
         return outcome === "confident" || outcome === "resolved";
@@ -122,6 +128,9 @@ export function generatePolicyMarkdown(result, config, llmError) {
     if (result.unsupportedStackWarning) {
         parts.push(renderUnsupportedStackWarning(result.unsupportedStackWarning), "");
     }
+    if (protectedLogicWarning) {
+        parts.push(renderProtectedLogicWarning(protectedLogicWarning), "");
+    }
     if (llmError) {
         parts.push(renderLlmErrorWarning(llmError), "");
     }

package/dist/policy/legalNotices.d.ts

@@ -0,0 +1,5 @@
+export declare const PRIVACY_POLICY_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export declare const TERMS_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export declare const NETWORK_CALLS_NOTICE: string;
+export declare const SCAN_DISCLAIMER_REMINDER = "Reminder: this is automated analysis, not legal advice \u2014 review the generated policy before publishing it.";
+export declare function byokNetworkNotice(apiKeyEnvVar: string | null): string;

package/dist/policy/legalNotices.js

@@ -0,0 +1,29 @@
+// No dedicated privacy-policy/terms site exists yet -- these point at the real, resolvable README
+// "Legal" section that covers the same ground today (not a placeholder or a dead `.invalid` link), and
+// should be repointed to a real site once one exists. Kept as named constants precisely so there's one
+// place to update when that happens -- a one-line change, not a hunt through every call site.
+//
+// Deliberately NOT labeled "Privacy policy:" / "Terms:" below: that would claim those documents exist
+// at this URL, when the Legal section itself says plainly that they don't yet -- this points at a
+// notice and disclaimer, not a substitute for either.
+export const PRIVACY_POLICY_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+export const TERMS_URL = "https://github.com/SrcLawyer/srclawyer#legal";
+// Verbatim from README.md's own "Network calls" section (minus markdown backticks, since this prints
+// to a terminal) -- one wording for this claim, not a second paraphrase that can drift from the first.
+export const NETWORK_CALLS_NOTICE = [
+    "Heads up: SrcLawyer makes network calls.",
+    "",
+    "Detection itself is fully local and offline — no code leaves your machine for pattern matching.",
+    "Once detection completes, scan makes one batched network call to grade the confidence of what it",
+    "found (field names and derived yes/no signals only, never source code), and, for scans that use Zod",
+    "schemas as request validators, one additional call sending a small redacted code fragment. This runs",
+    "on every scan regardless of tier.",
+    "",
+    `Legal notice and disclaimer: ${PRIVACY_POLICY_URL}`,
+    "(A dedicated privacy policy and terms of service are coming; this points to what exists today.)",
+].join("\n");
+export const SCAN_DISCLAIMER_REMINDER = "Reminder: this is automated analysis, not legal advice — review the generated policy before publishing it.";
+export function byokNetworkNotice(apiKeyEnvVar) {
+    const keySource = apiKeyEnvVar ? `env var ${apiKeyEnvVar}` : "your configured key";
+    return `BYOK is configured: redacted code snippets for ambiguous findings will be sent to Anthropic under your own API key (${keySource}), for AI-assisted classification only.`;
+}

package/dist/report/formatText.js

@@ -38,7 +38,7 @@ export function formatText(result) {
     }
     else if (result.ambiguousCount > 0) {
         lines.push("");
-        lines.push(`${result.ambiguousCount} item(s) require deeper analysis before they can be included in a policy. Run "srclawyer scan" with a "byok"/"managed" tier configured to attempt AI-assisted resolution, or resolve manually.`);
+        lines.push(`${result.ambiguousCount} item(s) require deeper analysis before they can be included in a policy. Run "srclawyer scan" with the "byok" tier configured (bring your own Anthropic key) to attempt AI-assisted resolution, or resolve manually. A "managed" tier is planned but not yet available.`);
     }
     return lines.join("\n");
 }

package/dist/rules/dataCategoryLexicon.js

@@ -1,9 +1,15 @@
 const LEXICON = [
     { pattern: /email/i, category: "email" },
-    // Checked before the generic "name" pattern below: bank_name/account_holder_name end in
-    // "name" and would otherwise be classified as just "name", losing the payment-specific signal.
     { pattern: /bank[ _-]?name|routing[ _-]?number|account[ _-]?holder|iban|swift[ _-]?code/i, category: "payment_info" },
-    { pattern: /(full)?name$|firstname|lastname|surname/i, category: "name" },
+    // Anchored to the whole field name, not a bare "...name$" suffix match: the old pattern matched
+    // ANY field ending in "name" -- hostname, filename, directoryName, className, teamName, etc. -- none
+    // of which are a person's name. This matches only "name" itself and the known person-name
+    // decompositions (first/last/middle/maiden/nick/display/legal name, username), each allowing an
+    // optional separator (first_name, firstName, first-name). A compound this doesn't recognize falls
+    // through with no category match, landing in the same "could not confidently classify — needs
+    // review" path as any other unclassified field -- not the safe list, not a new discard path, just
+    // the existing honest-ambiguity treatment.
+    { pattern: /^(full|first|middle|last|sur|maiden|nick|display|legal)[\s_-]*name$|^name$|^user[\s_-]*name$/i, category: "name" },
     { pattern: /phone|mobile|telephone/i, category: "phone" },
     { pattern: /address|street|city|zip ?code|postal ?code/i, category: "physical_address" },
     { pattern: /card ?number|creditcard|cvv|cvc|cardholder/i, category: "payment_info" },

package/dist/rules/frameworkRules.js

@@ -18,6 +18,54 @@ function fieldsFromObjectPattern(pattern) {
     }
     return names;
 }
+function isRequestBodyMemberExpression(node) {
+    return (node.type === "MemberExpression" &&
+        !node.computed &&
+        node.object.type === "Identifier" &&
+        REQUEST_OBJECT_NAMES.test(node.object.name) &&
+        node.property.type === "Identifier" &&
+        REQUEST_BODY_PROPS.test(node.property.name));
+}
+function isAwaitedRequestJsonCall(node) {
+    return (node.type === "AwaitExpression" &&
+        node.argument.type === "CallExpression" &&
+        node.argument.callee.type === "MemberExpression" &&
+        node.argument.callee.object.type === "Identifier" &&
+        REQUEST_OBJECT_NAMES.test(node.argument.callee.object.name) &&
+        node.argument.callee.property.type === "Identifier" &&
+        node.argument.callee.property.name === "json");
+}
+/**
+ * Same-function alias tracking: `const body = req.body` (or `req.query`/`req.params`, or
+ * `await req.json()`) followed by `body.email` / `body['email']` / `const { email } = body` in the
+ * same function body. Deliberately one mechanical hop, scoped to the nearest enclosing function (or
+ * module/program scope for top-level code) via Babel's own `getFunctionParent()` -- not general
+ * dataflow: no cross-function tracking, no chained reassignment, no closures capturing an outer
+ * function's alias. Mirrors pythonFrameworkRules.ts's same-function alias tracking exactly, for the
+ * same reason: `const body = req.body; body.email` was structurally invisible before this, just like
+ * `data = request.get_json(); data['email']` was on the Python side.
+ */
+function collectRequestAliases(ast) {
+    const aliasesByScope = new Map();
+    traverse(ast, {
+        VariableDeclarator(path) {
+            const id = path.node.id;
+            const init = path.node.init;
+            if (!init || id.type !== "Identifier")
+                return;
+            if (!isRequestBodyMemberExpression(init) && !isAwaitedRequestJsonCall(init))
+                return;
+            const scope = path.getFunctionParent()?.node ?? ast.program;
+            const aliases = aliasesByScope.get(scope) ?? new Set();
+            aliases.add(id.name);
+            aliasesByScope.set(scope, aliases);
+        },
+    });
+    return aliasesByScope;
+}
+function enclosingScope(path, ast) {
+    return path.getFunctionParent()?.node ?? ast.program;
+}
 export function runFrameworkRules(ast, filePath, source, root) {
     const findings = [];
     const lines = source.split("\n");
@@ -53,24 +101,38 @@ export function runFrameworkRules(ast, filePath, source, root) {
             confidenceFactors: { lexiconCategory, ambiguousName, runtimeVerified: true, siblingConfidentCount },
         });
     }
+    const aliasesByScope = collectRequestAliases(ast);
+    const isAliasReference = (path, name) => !!aliasesByScope.get(enclosingScope(path, ast))?.has(name);
     traverse(ast, {
         MemberExpression(path) {
-            const { object, property } = path.node;
-            if (object.type !== "Identifier" || !REQUEST_OBJECT_NAMES.test(object.name))
+            const { object, property, computed } = path.node;
+            if (object.type !== "Identifier")
                 return;
-            if (property.type !== "Identifier" || !REQUEST_BODY_PROPS.test(property.name))
+            if (REQUEST_OBJECT_NAMES.test(object.name) && !computed && property.type === "Identifier" && REQUEST_BODY_PROPS.test(property.name)) {
+                const parent = path.parent;
+                if (parent.type === "MemberExpression" && parent.property.type === "Identifier") {
+                    emit(parent.property.name, parent.loc?.start.line ?? path.node.loc?.start.line ?? 1, parent);
+                    return;
+                }
+                if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
+                    const line = parent.loc?.start.line ?? 1;
+                    const siblingFieldNames = fieldsFromObjectPattern(parent.id);
+                    for (const fieldName of siblingFieldNames) {
+                        emit(fieldName, line, parent, siblingFieldNames);
+                    }
+                }
                 return;
-            const parent = path.parent;
-            if (parent.type === "MemberExpression" && parent.property.type === "Identifier") {
-                emit(parent.property.name, parent.loc?.start.line ?? path.node.loc?.start.line ?? 1, parent);
+            }
+            // Alias reference: `body.email` or `body['email']`, where `body` was assigned from
+            // req.body/.query/.params or await req.json() earlier in the same function.
+            if (!isAliasReference(path, object.name))
                 return;
+            const line = path.node.loc?.start.line ?? 1;
+            if (!computed && property.type === "Identifier") {
+                emit(property.name, line, path.node);
             }
-            if (parent.type === "VariableDeclarator" && parent.id.type === "ObjectPattern") {
-                const line = parent.loc?.start.line ?? 1;
-                const siblingFieldNames = fieldsFromObjectPattern(parent.id);
-                for (const fieldName of siblingFieldNames) {
-                    emit(fieldName, line, parent, siblingFieldNames);
-                }
+            else if (computed && property.type === "StringLiteral") {
+                emit(property.value, line, path.node);
             }
         },
         AwaitExpression(path) {
@@ -93,6 +155,21 @@ export function runFrameworkRules(ast, filePath, source, root) {
                 }
             }
         },
+        VariableDeclarator(path) {
+            // Alias destructure: `const { email } = body`, where `body` was assigned from
+            // req.body/.query/.params or await req.json() earlier in the same function.
+            const init = path.node.init;
+            const id = path.node.id;
+            if (!init || init.type !== "Identifier" || id.type !== "ObjectPattern")
+                return;
+            if (!isAliasReference(path, init.name))
+                return;
+            const line = path.node.loc?.start.line ?? 1;
+            const siblingFieldNames = fieldsFromObjectPattern(id);
+            for (const fieldName of siblingFieldNames) {
+                emit(fieldName, line, path.node, siblingFieldNames);
+            }
+        },
     });
     return findings;
 }

package/dist/rules/pythonFrameworkRules.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from "web-tree-sitter";
+import type { Finding } from "../engine/types.js";
+export declare function runPythonFrameworkRules(tree: Tree, filePath: string, source: string, root: string): Finding[];

package/dist/rules/pythonFrameworkRules.js

@@ -0,0 +1,136 @@
+import { relative } from "node:path";
+import { classifyFieldName, isAmbiguousFieldName } from "./dataCategoryLexicon.js";
+import { isSafeFieldName } from "./safeFieldNames.js";
+import { redactSecrets } from "../engine/secretRedaction.js";
+import { countConfidentSiblings } from "./confidenceFactors.js";
+/**
+ * Flask's incoming-request accessors: request.form / request.json / request.args. Anchored to the
+ * literal name "request" rather than a configurable-name regex (unlike Express's req/request, which
+ * is a per-handler parameter that can be named anything) -- Flask's `request` is always the direct,
+ * module-level import from `flask`, used by that exact name in effectively all real code.
+ */
+const REQUEST_ATTR = /^request\.(form|json|args)$/;
+const REQUEST_GET_CALL = /^request\.(form|json|args)\.get$/;
+const REQUEST_GET_JSON_CALL = /^request\.get_json$/;
+function stringLiteralContent(node) {
+    if (!node || node.type !== "string")
+        return null;
+    return node.descendantsOfType("string_content")[0]?.text ?? null;
+}
+/** True for the RHS of `x = <this>`: request.form / .json / .args, or a request.get_json() call. */
+function isRequestDataSource(node) {
+    if (node.type === "attribute")
+        return REQUEST_ATTR.test(node.text);
+    if (node.type === "call") {
+        const fn = node.childForFieldName("function");
+        return !!fn && REQUEST_GET_JSON_CALL.test(fn.text);
+    }
+    return false;
+}
+/**
+ * The nearest enclosing function_definition's node id, or -1 for module-level code. Scoped by `.id`
+ * rather than the Node object itself -- web-tree-sitter doesn't guarantee the same underlying syntax
+ * node comes back as the same JS object identity across separate traversal calls (same `.id`, new
+ * wrapper), so using Node references as Map keys silently never matches.
+ */
+function enclosingScopeId(node) {
+    let current = node.parent;
+    while (current) {
+        if (current.type === "function_definition")
+            return current.id;
+        current = current.parent;
+    }
+    return -1;
+}
+/**
+ * Same-function alias tracking: `data = request.get_json()` (or `= request.form` / `.json` / `.args`)
+ * followed by `data['x']` / `data.get('x')` in the same function body. Deliberately one mechanical hop,
+ * scoped to the nearest enclosing function (or module level), not general dataflow -- no cross-function
+ * tracking, no chained reassignment, no branch/conditional awareness, no closures capturing an outer
+ * function's alias. This is exactly the gap the microblog golden-corpus entry documented: real signup
+ * PII read via request.get_json() into a local variable rather than a direct request.json[...] subscript.
+ */
+function collectRequestAliases(tree) {
+    const aliasesByScope = new Map();
+    for (const node of tree.rootNode.descendantsOfType("assignment")) {
+        const left = node.childForFieldName("left");
+        const right = node.childForFieldName("right");
+        if (!left || left.type !== "identifier" || !right || !isRequestDataSource(right))
+            continue;
+        const scope = enclosingScopeId(node);
+        const aliases = aliasesByScope.get(scope) ?? new Set();
+        aliases.add(left.text);
+        aliasesByScope.set(scope, aliases);
+    }
+    return aliasesByScope;
+}
+function collectFieldAccesses(tree) {
+    const accesses = [];
+    const aliasesByScope = collectRequestAliases(tree);
+    const isAliasReference = (node) => !!node && node.type === "identifier" && !!aliasesByScope.get(enclosingScopeId(node))?.has(node.text);
+    for (const node of tree.rootNode.descendantsOfType("subscript")) {
+        const value = node.childForFieldName("value");
+        if (!value)
+            continue;
+        const isDirect = REQUEST_ATTR.test(value.text) || (value.type === "call" && isRequestDataSource(value));
+        if (!isDirect && !isAliasReference(value))
+            continue;
+        const key = stringLiteralContent(node.childForFieldName("subscript"));
+        if (key)
+            accesses.push({ fieldName: key, line: node.startPosition.row + 1 });
+    }
+    for (const node of tree.rootNode.descendantsOfType("call")) {
+        const fn = node.childForFieldName("function");
+        if (!fn)
+            continue;
+        const isDirectGet = REQUEST_GET_CALL.test(fn.text);
+        const isAliasGet = fn.type === "attribute" &&
+            fn.childForFieldName("attribute")?.text === "get" &&
+            isAliasReference(fn.childForFieldName("object"));
+        if (!isDirectGet && !isAliasGet)
+            continue;
+        const args = node.childForFieldName("arguments")?.namedChildren ?? [];
+        const key = stringLiteralContent(args[0] ?? null);
+        if (key)
+            accesses.push({ fieldName: key, line: node.startPosition.row + 1 });
+    }
+    return accesses;
+}
+export function runPythonFrameworkRules(tree, filePath, source, root) {
+    const lines = source.split("\n");
+    const relPath = relative(root, filePath);
+    const accesses = collectFieldAccesses(tree);
+    const allFieldNames = accesses.map((a) => a.fieldName);
+    const findings = [];
+    const emitted = new Set();
+    for (const { fieldName, line } of accesses) {
+        if (isSafeFieldName(fieldName))
+            continue;
+        const dedupeKey = `${fieldName}:${line}`;
+        if (emitted.has(dedupeKey))
+            continue;
+        emitted.add(dedupeKey);
+        const lexiconCategory = classifyFieldName(fieldName);
+        const ambiguousName = isAmbiguousFieldName(fieldName);
+        const siblingConfidentCount = countConfidentSiblings(allFieldNames, fieldName);
+        const evidenceLine = lines[line - 1] ?? "";
+        // Provisional confidence, patched by the batched protected-logic scoring call -- same pattern as
+        // frameworkRules.ts's JS equivalent; the scoring endpoint doesn't care which language a
+        // confidenceFactors-bearing finding came from.
+        findings.push({
+            id: `field:${relPath}:${line}:${fieldName}`,
+            dataCategories: lexiconCategory ? [lexiconCategory] : ["generic_pii"],
+            processor: null,
+            description: lexiconCategory
+                ? `Request field "${fieldName}" collected, classified as ${lexiconCategory}.`
+                : `Request field "${fieldName}" collected; could not confidently classify — needs review.`,
+            confidence: "low",
+            source: "framework-rule",
+            location: { file: relPath, line, column: 0 },
+            evidence: redactSecrets(evidenceLine.trim()).slice(0, 200),
+            requiresReview: true,
+            confidenceFactors: { lexiconCategory, ambiguousName, runtimeVerified: true, siblingConfidentCount },
+        });
+    }
+    return findings;
+}

package/dist/rules/pythonSdkRules.d.ts

@@ -0,0 +1,3 @@
+import type { Tree } from "web-tree-sitter";
+import type { Finding } from "../engine/types.js";
+export declare function runPythonSdkRules(tree: Tree, filePath: string, source: string, root: string): Finding[];

package/dist/rules/pythonSdkRules.js

@@ -0,0 +1,73 @@
+import { relative } from "node:path";
+import { PROCESSOR_PROFILES } from "./processorProfiles.js";
+import { redactSecrets } from "../engine/secretRedaction.js";
+/**
+ * Deliberately narrower than sdkRules.ts's JS table -- not every processor has a reliable
+ * import-name signal in Python's ecosystem:
+ *   - Cognito: Python code almost always calls it through boto3, AWS's *general* SDK used for every
+ *     AWS service (S3, DynamoDB, SQS, ...). Mapping a bare `import boto3` to "Amazon Cognito" would be
+ *     wrong far more often than right; reliably detecting it needs finding the specific
+ *     `boto3.client("cognito-idp")` call, not just the import -- a real gap, not covered here.
+ *   - Google Analytics: no single well-known, unambiguous pip import root the way `stripe` or
+ *     `twilio` are for their processors. Left out rather than guessed.
+ */
+const SDK_MATCHERS = [
+    { processorKey: "stripe", moduleNames: ["stripe"] },
+    { processorKey: "sendgrid", moduleNames: ["sendgrid"] },
+    { processorKey: "twilio", moduleNames: ["twilio"] },
+    { processorKey: "mixpanel", moduleNames: ["mixpanel"] },
+    { processorKey: "auth0", moduleNames: ["auth0"] },
+    // PyPI package is "firebase-admin"; its import root is firebase_admin.
+    { processorKey: "firebase", moduleNames: ["firebase_admin"] },
+];
+function matchProcessor(moduleRoot) {
+    return SDK_MATCHERS.find((matcher) => matcher.moduleNames.includes(moduleRoot));
+}
+/** The root package name from a dotted module path node (e.g. "twilio" from "twilio.rest"). */
+function moduleRootName(moduleNameNode) {
+    if (!moduleNameNode)
+        return null;
+    if (moduleNameNode.type === "dotted_name") {
+        return moduleNameNode.child(0)?.text ?? null;
+    }
+    if (moduleNameNode.type === "aliased_import") {
+        return moduleRootName(moduleNameNode.childForFieldName("name"));
+    }
+    // relative_import ("from . import x") and anything else has no external package name.
+    return null;
+}
+export function runPythonSdkRules(tree, filePath, source, root) {
+    const findings = [];
+    const lines = source.split("\n");
+    const relPath = relative(root, filePath);
+    const seenProcessors = new Set();
+    const importNodes = [
+        ...tree.rootNode.descendantsOfType("import_statement"),
+        ...tree.rootNode.descendantsOfType("import_from_statement"),
+    ];
+    for (const node of importNodes) {
+        const fieldName = node.type === "import_statement" ? "name" : "module_name";
+        const moduleRoot = moduleRootName(node.childForFieldName(fieldName));
+        if (!moduleRoot)
+            continue;
+        const matcher = matchProcessor(moduleRoot);
+        if (!matcher || seenProcessors.has(matcher.processorKey))
+            continue;
+        seenProcessors.add(matcher.processorKey);
+        const profile = PROCESSOR_PROFILES[matcher.processorKey];
+        const line = node.startPosition.row + 1;
+        const evidenceLine = lines[line - 1] ?? "";
+        findings.push({
+            id: `sdk:${matcher.processorKey}:${relPath}:${line}`,
+            dataCategories: profile.dataCategories,
+            processor: profile.name,
+            description: `${profile.name} integration detected. ${profile.disclosureNotes}`,
+            confidence: "high",
+            source: "sdk-rule",
+            location: { file: relPath, line, column: 0 },
+            evidence: redactSecrets(evidenceLine.trim()),
+            requiresReview: false,
+        });
+    }
+    return findings;
+}

package/dist/rules/safeFieldNames.js

@@ -1,3 +1,9 @@
+// Exact-match only, deliberately narrow -- this is the one silent-drop path in the whole pipeline
+// (a name on this list never becomes a finding at all, not even a low-confidence one flagged for
+// review). Names that are ALSO plausible PII in some real API (e.g. "next"/"prev" as redirect
+// targets, "since"/"until"/"before"/"after" as ambiguous short words) are deliberately left off even
+// when they're common pagination/cursor names elsewhere, so they stay visible for manual review
+// rather than being silently and permanently suppressed.
 const SAFE_FIELD_NAMES = new Set([
     "id",
     "uuid",
@@ -16,6 +22,14 @@ const SAFE_FIELD_NAMES = new Set([
     "total",
     "sort",
     "order",
+    "perpage",
+    "pagesize",
+    "cursor",
+    "nextcursor",
+    "prevcursor",
+    "sortby",
+    "orderby",
+    "sortorder",
 ]);
 function normalize(fieldName) {
     return fieldName.toLowerCase().replace(/[^a-z0-9]/g, "");

package/dist/rules/zodPreFilter.d.ts

@@ -1,3 +1,17 @@
+/**
+ * A hard ceiling, not a normal operating limit: protectedLogicClient.ts batches by total bytes, so a
+ * large fragment is sent ALONE in its own request rather than bundled with others -- the actual
+ * per-batch CPU risk that caused intermittent "Worker exceeded CPU time limit" failures (confirmed via
+ * wrangler tail) is handled there, not here. This constant exists only to refuse something pathological
+ * (e.g. a machine-generated file with one enormous schema), not to cap ordinary real-world files -- and
+ * trimmed extraction (above) means ordinary files need it even less than before.
+ *
+ * Measured (uncapped, pre-trimming) across the three golden-corpus repos: max 41,992 bytes
+ * (formbricks/packages/types/surveys/types.ts). This value is PROVISIONAL and unvalidated against the
+ * real Worker limit: that depends on a Cloudflare plan upgrade that hasn't happened yet. Revisit once
+ * the upgrade is confirmed and the 10-run wrangler tail test has been repeated.
+ */
+export declare const MAX_FRAGMENT_BYTES = 65536;
 export interface ZodCandidate {
     id: string;
     codeFragment: string;
@@ -6,4 +20,10 @@ export interface ZodCandidate {
      *  since the fragment is a non-contiguous excerpt of the original file, not a raw slice. */
     fragmentLineToSourceLine: number[];
 }
-export declare function findZodCandidates(source: string, filePath: string, root: string): ZodCandidate[];
+export interface FindZodCandidatesResult {
+    candidates: ZodCandidate[];
+    /** Relative paths of files whose extracted fragment exceeded MAX_FRAGMENT_BYTES and was dropped
+     *  rather than sent -- the caller must surface these, never drop them silently. */
+    oversizedFiles: string[];
+}
+export declare function findZodCandidates(source: string, filePath: string, root: string): FindZodCandidatesResult;