circle-ir 3.177.0 → 3.179.0

package/dist/analysis/dependency-versions.d.ts

@@ -0,0 +1,214 @@
+/**
+ * Dependency-manifest helpers for the deserialization-safety-gate pass.
+ *
+ * cognium-dev #258 — dependency-version-aware sink gating. The engine
+ * never reads the filesystem (Pillar I / browser-safety); the caller
+ * (cognium-dev CLI or `analyzeProject`) reads the manifest and passes
+ * it as raw text via `AnalyzerOptions.dependencyContext`. Helpers here
+ * turn that raw text into the boolean predicates the gate needs.
+ *
+ * All parsers here are string-scoped: regex over the raw manifest
+ * rather than a full XML/JSON tree. That is deliberate — the gate only
+ * needs a handful of narrow signals (Fastjson version, presence of a
+ * safe classifier), and every existing runtime dep in circle-ir is
+ * either `web-tree-sitter` or `yaml`. Pulling in an XML parser purely
+ * for one Fastjson property would violate the minimal-dependencies
+ * guardrail.
+ */
+/**
+ * Result of extracting the effective Fastjson coordinate from a
+ * `pom.xml` string. `version` is the raw value as declared (including
+ * any classifier suffix); `noneAutotype` is true when the version
+ * literally matches Alibaba's `_noneautotype` hardened build family
+ * (any patch level, e.g. `1.2.83_noneautotype`, `1.2.85_noneautotype`).
+ */
+export interface FastjsonPomResolution {
+    version: string;
+    noneAutotype: boolean;
+}
+/**
+ * Extract the effective Fastjson version from a `pom.xml`. Two sources
+ * are consulted:
+ *
+ *   1. A `<properties>` entry named exactly `<fastjson.version>` — the
+ *      idiomatic way Maven projects centralise a dep version they
+ *      reference in a `<dependencies>` block. This is where
+ *      alibaba/Sentinel pins `1.2.83_noneautotype`.
+ *   2. A `<dependency>` block whose `<groupId>` is `com.alibaba` and
+ *      `<artifactId>` is `fastjson` — read as a fallback when the
+ *      version is declared inline rather than as a property.
+ *
+ * Returns `null` when no Fastjson coordinate can be resolved from the
+ * pom (no properties entry AND no matching dependency block, or the
+ * dependency uses a `${...}` reference the properties block doesn't
+ * define).
+ */
+export declare function resolveFastjsonFromPom(pomXml: string): FastjsonPomResolution | null;
+/**
+ * Extract the effective Fastjson version from a Gradle build script
+ * (`build.gradle` Groovy DSL or `build.gradle.kts` Kotlin DSL).
+ *
+ * cognium-dev #261 (Gradle-first slice extending #258's pom.xml gate).
+ *
+ * Recognises three declaration shapes:
+ *
+ *   1. Direct literal — the classic Groovy / Kotlin single-string form:
+ *        implementation 'com.alibaba:fastjson:1.2.83_noneautotype'
+ *        implementation "com.alibaba:fastjson:1.2.83_noneautotype"
+ *        implementation("com.alibaba:fastjson:1.2.83_noneautotype")
+ *      Also `api`, `compile`, `runtimeOnly`, `testImplementation`, … — the
+ *      configuration keyword is not part of the regex; only the
+ *      `group:artifact:version` triple is matched, so any dependency-
+ *      configuration prefix works.
+ *
+ *   2. Groovy interpolation — `implementation "com.alibaba:fastjson:${fastjsonVersion}"`
+ *      with the property defined via `ext { fastjsonVersion = '1.2.83_noneautotype' }`,
+ *      `def fastjsonVersion = '1.2.83_noneautotype'`, or top-level `fastjsonVersion = '…'`.
+ *
+ *   3. Kotlin interpolation — `implementation("com.alibaba:fastjson:$fastjsonVersion")`
+ *      with the property defined via `val fastjsonVersion = "1.2.83_noneautotype"`
+ *      or `const val fastjsonVersion = "…"`.
+ *
+ * Returns `null` on miss (no direct declaration AND no resolvable
+ * property reference). The `DeserializationSafetyGatePass` then falls
+ * through to its default "do not drop" behaviour on the sink.
+ *
+ * NOT recognised in this MVP (deferred, follow-ups on #261):
+ *   - `platform(...)` / `enforcedPlatform(...)` BOM version imports
+ *   - Version-catalog `libs.versions.toml` references (`libs.fastjson`)
+ *   - `constraints { }` block versions
+ *   - `subprojects { }` / `allprojects { }` conditional declarations
+ */
+export declare function resolveFastjsonFromGradle(buildGradle: string): FastjsonPomResolution | null;
+/**
+ * Result of extracting the effective PyYAML version. `safeByDefault` is
+ * true when the parsed version is ≥ 6.0; at that point pyyaml.load()
+ * without an explicit `Loader=` keyword argument raises TypeError
+ * instead of silently invoking the unsafe default Loader.
+ *
+ * See https://github.com/yaml/pyyaml/blob/master/CHANGES for the full
+ * 6.0 breakage story. The gate consumer must ALSO check the call site
+ * for an explicit `Loader=` keyword (fileHasUnsafePyYamlLoader below)
+ * — a caller under pyyaml ≥ 6.0 that explicitly passes
+ * `Loader=yaml.Loader` or `Loader=yaml.UnsafeLoader` is still
+ * dangerous regardless of the version pin.
+ */
+export interface PyYamlResolution {
+    version: string;
+    safeByDefault: boolean;
+}
+/**
+ * Extract the effective PyYAML version from a `requirements.txt` file.
+ * Recognises the standard PEP 508 shapes (`==`, `>=`, `~=`, `>`,
+ * exact pins with trailing modifiers). Package name matched
+ * case-insensitively (both `PyYAML` and `pyyaml` are common in the
+ * wild).
+ *
+ * Returns null when no pyyaml line is found or the version string
+ * cannot be parsed as `M.m[.p]`. Non-strict on trailing environment
+ * markers (` ; python_version >= '3.6'`), which are common on
+ * requirements.txt lines.
+ */
+export declare function resolvePyYamlFromRequirements(requirementsTxt: string): PyYamlResolution | null;
+/**
+ * Extract the effective PyYAML version from a `pyproject.toml`.
+ * Recognises the common Poetry and PEP 621 shapes:
+ *
+ *   Poetry — under `[tool.poetry.dependencies]`:
+ *     PyYAML = "6.0"
+ *     pyyaml = "^6.0.1"
+ *     pyyaml = { version = "6.0", extras = ["..."] }
+ *
+ *   PEP 621 — under `[project]` `dependencies` array:
+ *     dependencies = [ "PyYAML>=6.0", ... ]
+ *
+ * As with the requirements.txt resolver, non-strict on markers /
+ * modifiers; regex-based rather than a full TOML parser to keep the
+ * runtime-dep list minimal (Pillar I minimal-dependencies principle).
+ */
+export declare function resolvePyYamlFromPyproject(pyprojectToml: string): PyYamlResolution | null;
+/**
+ * True when `version` (as `M.m[.p]`) is ≥ 6.0. Handles bare `6`,
+ * `6.0`, `6.0.1`, `7`, `10.0`, etc. Returns false on malformed input
+ * (defensive — the gate defaults to *do not drop* on missing signal).
+ */
+export declare function isPyYamlVersionSafeByDefault(version: string): boolean;
+/**
+ * Return true when the file contains an explicit unsafe `Loader=`
+ * keyword argument on a `yaml.load(...)` call at or shortly after
+ * `sinkLine`. Recognises the well-known unsafe loaders and their
+ * qualified forms:
+ *
+ *   Loader=Loader         Loader=yaml.Loader
+ *   Loader=UnsafeLoader   Loader=yaml.UnsafeLoader
+ *   Loader=FullLoader     Loader=yaml.FullLoader   (technically safer
+ *                                                   than Loader; still
+ *                                                   permits arbitrary
+ *                                                   Python object types)
+ *
+ * SafeLoader / CSafeLoader / BaseLoader / CBaseLoader are all safe and
+ * are NOT matched here.
+ *
+ * Scans `sinkLine` through the next 9 lines to catch multi-line call
+ * shapes; if the closing `)` appears before the window ends the scan
+ * stops there. Regex-based (no AST inspection) to stay consistent with
+ * the sink-filter-pass conventions and avoid pulling parse state into
+ * the gate.
+ */
+export declare function fileHasUnsafePyYamlLoader(sourceLines: string[], sinkLine: number): boolean;
+/**
+ * Return true when the given source text contains an in-file call that
+ * re-enables Fastjson autotype. Even a `_noneautotype` build does not
+ * protect against code that programmatically re-enables the feature
+ * (which the hardened build documents as impossible, but the classifier
+ * is a build-time strip, not a runtime lock). Defense-in-depth for the
+ * `resolveFastjsonFromPom` gate.
+ */
+export declare function fileReenablesFastjsonAutotype(source: string): boolean;
+/**
+ * Return true when the given Java source contains a call that enables
+ * Jackson polymorphic type handling — either the legacy
+ * `enableDefaultTyping(...)` (deprecated in Jackson 2.10+ but still
+ * shipped) or the current `activateDefaultTyping(...)`.
+ *
+ * When neither is present in the file (and no `@JsonTypeInfo` is used
+ * on the target type — best-effort scan below), Jackson's default
+ * behaviour since 2.10 is safe: `ObjectMapper.readValue(json,
+ * targetType)` cannot instantiate arbitrary classes. The gate uses
+ * this to distinguish a genuine `readValue` sink from a safely-
+ * configured one.
+ *
+ * `@JsonTypeInfo` scan is intentionally file-local. A `@JsonTypeInfo`
+ * annotation on a target type in a different file would still allow
+ * polymorphic construction, but the engine treats that as unknown
+ * risk and preserves the sink (the gate only fires when the *file
+ * itself* provides positive evidence of a safe configuration).
+ */
+export declare function fileEnablesJacksonPolymorphism(source: string): boolean;
+/**
+ * Return true when the given Java source contains a
+ * `new Yaml(new SafeConstructor(...))` or an equivalent hardened
+ * SnakeYAML constructor. When any `Yaml` instance in the file is
+ * built with the safe constructor family, we assume the file's
+ * `Yaml.load(...)` calls are safely configured; the gate then drops
+ * the deserialization sink for those calls.
+ *
+ * Recognised safe constructor classes (SnakeYAML 1.x + 2.x):
+ *   - SafeConstructor              — canonical safe loader
+ *   - SafeSchema (rare, YAML 1.2)  — safe schema-based loader
+ *
+ * Recognised safe factory calls (SnakeYAML 2.x LoaderOptions API):
+ *   - Yaml.load()   with a Constructor that extends SafeConstructor
+ *     (heuristic: any `SafeConstructor`-typed variable is safe)
+ *
+ * NOTE: A file that mixes `new Yaml(new SafeConstructor())` with
+ * `new Yaml(new Constructor(SomeClass.class))` on separate call sites
+ * would over-suppress the unsafe site. In practice this is rare (SAST
+ * teams write one wrapper per file), and the current sink-filter
+ * stage 9b handles the analogous compiled-template case with the same
+ * file-scoped heuristic. If it becomes a problem, tighten to
+ * receiver-scoped: check the specific `Yaml` receiver that carries
+ * the load() call.
+ */
+export declare function fileConfiguresSnakeYamlSafely(source: string): boolean;
+//# sourceMappingURL=dependency-versions.d.ts.map

package/dist/analysis/dependency-versions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-versions.d.ts","sourceRoot":"","sources":["../../src/analysis/dependency-versions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CA8BnF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,yBAAyB,CAAC,WAAW,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAsC3F;AAMD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,OAAO,CAAC;CACxB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,MAAM,GACtB,gBAAgB,GAAG,IAAI,CAuBzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,MAAM,GACpB,gBAAgB,GAAG,IAAI,CAiCzB;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAIrE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EAAE,EACrB,QAAQ,EAAE,MAAM,GACf,OAAO,CAkBT;AAED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAKrE;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,8BAA8B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAUtE;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,6BAA6B,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAOrE"}

package/dist/analysis/dependency-versions.js

@@ -0,0 +1,352 @@
+/**
+ * Dependency-manifest helpers for the deserialization-safety-gate pass.
+ *
+ * cognium-dev #258 — dependency-version-aware sink gating. The engine
+ * never reads the filesystem (Pillar I / browser-safety); the caller
+ * (cognium-dev CLI or `analyzeProject`) reads the manifest and passes
+ * it as raw text via `AnalyzerOptions.dependencyContext`. Helpers here
+ * turn that raw text into the boolean predicates the gate needs.
+ *
+ * All parsers here are string-scoped: regex over the raw manifest
+ * rather than a full XML/JSON tree. That is deliberate — the gate only
+ * needs a handful of narrow signals (Fastjson version, presence of a
+ * safe classifier), and every existing runtime dep in circle-ir is
+ * either `web-tree-sitter` or `yaml`. Pulling in an XML parser purely
+ * for one Fastjson property would violate the minimal-dependencies
+ * guardrail.
+ */
+/**
+ * Extract the effective Fastjson version from a `pom.xml`. Two sources
+ * are consulted:
+ *
+ *   1. A `<properties>` entry named exactly `<fastjson.version>` — the
+ *      idiomatic way Maven projects centralise a dep version they
+ *      reference in a `<dependencies>` block. This is where
+ *      alibaba/Sentinel pins `1.2.83_noneautotype`.
+ *   2. A `<dependency>` block whose `<groupId>` is `com.alibaba` and
+ *      `<artifactId>` is `fastjson` — read as a fallback when the
+ *      version is declared inline rather than as a property.
+ *
+ * Returns `null` when no Fastjson coordinate can be resolved from the
+ * pom (no properties entry AND no matching dependency block, or the
+ * dependency uses a `${...}` reference the properties block doesn't
+ * define).
+ */
+export function resolveFastjsonFromPom(pomXml) {
+    if (!pomXml)
+        return null;
+    const propMatch = pomXml.match(/<fastjson\.version>\s*([^<\s]+)\s*<\/fastjson\.version>/);
+    if (propMatch) {
+        const version = propMatch[1];
+        return { version, noneAutotype: /_noneautotype/i.test(version) };
+    }
+    // Fallback: scan every <dependency>...</dependency> block for
+    // com.alibaba:fastjson (or fastjson2). Non-greedy so we don't fuse
+    // sibling blocks. Case-sensitive on artifact / group; Maven's own
+    // resolution is case-sensitive too.
+    const depRe = /<dependency>[\s\S]*?<\/dependency>/g;
+    let m;
+    while ((m = depRe.exec(pomXml)) !== null) {
+        const block = m[0];
+        const gid = block.match(/<groupId>\s*([^<\s]+)\s*<\/groupId>/)?.[1];
+        const aid = block.match(/<artifactId>\s*([^<\s]+)\s*<\/artifactId>/)?.[1];
+        if (gid !== 'com.alibaba')
+            continue;
+        if (aid !== 'fastjson' && aid !== 'fastjson2')
+            continue;
+        const ver = block.match(/<version>\s*([^<\s]+)\s*<\/version>/)?.[1];
+        if (!ver)
+            continue;
+        // `${fastjson.version}` reference the properties block did not
+        // resolve — treat as unknown so the gate defaults to fire.
+        if (/^\$\{/.test(ver))
+            return null;
+        return { version: ver, noneAutotype: /_noneautotype/i.test(ver) };
+    }
+    return null;
+}
+/**
+ * Extract the effective Fastjson version from a Gradle build script
+ * (`build.gradle` Groovy DSL or `build.gradle.kts` Kotlin DSL).
+ *
+ * cognium-dev #261 (Gradle-first slice extending #258's pom.xml gate).
+ *
+ * Recognises three declaration shapes:
+ *
+ *   1. Direct literal — the classic Groovy / Kotlin single-string form:
+ *        implementation 'com.alibaba:fastjson:1.2.83_noneautotype'
+ *        implementation "com.alibaba:fastjson:1.2.83_noneautotype"
+ *        implementation("com.alibaba:fastjson:1.2.83_noneautotype")
+ *      Also `api`, `compile`, `runtimeOnly`, `testImplementation`, … — the
+ *      configuration keyword is not part of the regex; only the
+ *      `group:artifact:version` triple is matched, so any dependency-
+ *      configuration prefix works.
+ *
+ *   2. Groovy interpolation — `implementation "com.alibaba:fastjson:${fastjsonVersion}"`
+ *      with the property defined via `ext { fastjsonVersion = '1.2.83_noneautotype' }`,
+ *      `def fastjsonVersion = '1.2.83_noneautotype'`, or top-level `fastjsonVersion = '…'`.
+ *
+ *   3. Kotlin interpolation — `implementation("com.alibaba:fastjson:$fastjsonVersion")`
+ *      with the property defined via `val fastjsonVersion = "1.2.83_noneautotype"`
+ *      or `const val fastjsonVersion = "…"`.
+ *
+ * Returns `null` on miss (no direct declaration AND no resolvable
+ * property reference). The `DeserializationSafetyGatePass` then falls
+ * through to its default "do not drop" behaviour on the sink.
+ *
+ * NOT recognised in this MVP (deferred, follow-ups on #261):
+ *   - `platform(...)` / `enforcedPlatform(...)` BOM version imports
+ *   - Version-catalog `libs.versions.toml` references (`libs.fastjson`)
+ *   - `constraints { }` block versions
+ *   - `subprojects { }` / `allprojects { }` conditional declarations
+ */
+export function resolveFastjsonFromGradle(buildGradle) {
+    if (!buildGradle)
+        return null;
+    // Shape 1 — direct literal declaration. Accepts single-quoted,
+    // double-quoted, or paren-wrapped ("Kotlin") forms. The version is
+    // any non-quote / non-`$` / non-`)` / non-whitespace run.
+    const directRe = /['"(]\s*com\.alibaba:fastjson:([^'"$\s)]+)\s*['")]/;
+    const direct = buildGradle.match(directRe);
+    if (direct) {
+        const version = direct[1];
+        return { version, noneAutotype: /_noneautotype/i.test(version) };
+    }
+    // Shapes 2 + 3 — property reference. Capture the property name (either
+    // `${name}` Groovy form or `$name` bare form; Kotlin uses the same
+    // string-template syntax as Groovy for this case).
+    const propRefRe = /['"(]\s*com\.alibaba:fastjson:\$\{?([A-Za-z_][A-Za-z0-9_]*)\}?\s*['")]/;
+    const propRef = buildGradle.match(propRefRe);
+    if (!propRef)
+        return null;
+    const propName = propRef[1];
+    // Property definition — accept:
+    //   `fastjsonVersion = 'X'`                (Groovy top-level or ext)
+    //   `fastjsonVersion = "X"`                (Groovy interpolated)
+    //   `def fastjsonVersion = 'X'`            (Groovy local)
+    //   `val fastjsonVersion = "X"`            (Kotlin)
+    //   `const val fastjsonVersion = "X"`      (Kotlin)
+    //   `fastjsonVersion: 'X'`                 (Groovy map-syntax, rare)
+    // Any leading whitespace / newlines / `=` / `:` before the quote.
+    const defRe = new RegExp(`\\b${propName}\\s*[=:]\\s*['"]([^'"\\s]+)['"]`);
+    const def = buildGradle.match(defRe);
+    if (!def)
+        return null;
+    const version = def[1];
+    return { version, noneAutotype: /_noneautotype/i.test(version) };
+}
+/**
+ * Extract the effective PyYAML version from a `requirements.txt` file.
+ * Recognises the standard PEP 508 shapes (`==`, `>=`, `~=`, `>`,
+ * exact pins with trailing modifiers). Package name matched
+ * case-insensitively (both `PyYAML` and `pyyaml` are common in the
+ * wild).
+ *
+ * Returns null when no pyyaml line is found or the version string
+ * cannot be parsed as `M.m[.p]`. Non-strict on trailing environment
+ * markers (` ; python_version >= '3.6'`), which are common on
+ * requirements.txt lines.
+ */
+export function resolvePyYamlFromRequirements(requirementsTxt) {
+    if (!requirementsTxt)
+        return null;
+    // Iterate line-by-line so a fatal parse error on one line doesn't
+    // sink the whole file. Comment lines and `-r other.txt` includes are
+    // ignored (we don't recurse into included files here — the caller
+    // controls what manifest string is passed).
+    for (const rawLine of requirementsTxt.split(/\r?\n/)) {
+        const line = rawLine.replace(/#.*$/, '').trim();
+        if (!line)
+            continue;
+        if (line.startsWith('-'))
+            continue;
+        // Match: `PyYAML==6.0`, `pyyaml>=6.0.1`, `PyYAML ~= 6.0`,
+        // `pyyaml>6`, `PyYAML==6.0 ; python_version>='3.6'`
+        const m = line.match(/^(pyyaml)\s*(==|>=|~=|>|===)\s*(\d+(?:\.\d+)*)/i);
+        if (!m)
+            continue;
+        const version = m[3];
+        return { version, safeByDefault: isPyYamlVersionSafeByDefault(version) };
+    }
+    return null;
+}
+/**
+ * Extract the effective PyYAML version from a `pyproject.toml`.
+ * Recognises the common Poetry and PEP 621 shapes:
+ *
+ *   Poetry — under `[tool.poetry.dependencies]`:
+ *     PyYAML = "6.0"
+ *     pyyaml = "^6.0.1"
+ *     pyyaml = { version = "6.0", extras = ["..."] }
+ *
+ *   PEP 621 — under `[project]` `dependencies` array:
+ *     dependencies = [ "PyYAML>=6.0", ... ]
+ *
+ * As with the requirements.txt resolver, non-strict on markers /
+ * modifiers; regex-based rather than a full TOML parser to keep the
+ * runtime-dep list minimal (Pillar I minimal-dependencies principle).
+ */
+export function resolvePyYamlFromPyproject(pyprojectToml) {
+    if (!pyprojectToml)
+        return null;
+    // Poetry key = string form.
+    //   PyYAML = "6.0"     PyYAML = "^6.0"     pyyaml = "~=6.0"
+    const poetryLine = pyprojectToml.match(/^\s*(pyyaml)\s*=\s*"([\^~=<>]*)(\d+(?:\.\d+)*)"/im);
+    if (poetryLine) {
+        const version = poetryLine[3];
+        return { version, safeByDefault: isPyYamlVersionSafeByDefault(version) };
+    }
+    // Poetry table form: `pyyaml = { version = "6.0", … }`
+    const poetryTable = pyprojectToml.match(/^\s*(pyyaml)\s*=\s*\{[^}]*\bversion\s*=\s*"([\^~=<>]*)(\d+(?:\.\d+)*)"/im);
+    if (poetryTable) {
+        const version = poetryTable[3];
+        return { version, safeByDefault: isPyYamlVersionSafeByDefault(version) };
+    }
+    // PEP 621 array element: within a `dependencies = [ ... ]` block, a
+    // string literal like `"PyYAML>=6.0"` or `"pyyaml==6.0.1"`.
+    const pep621 = pyprojectToml.match(/"(pyyaml)\s*(==|>=|~=|>|===)\s*(\d+(?:\.\d+)*)/i);
+    if (pep621) {
+        const version = pep621[3];
+        return { version, safeByDefault: isPyYamlVersionSafeByDefault(version) };
+    }
+    return null;
+}
+/**
+ * True when `version` (as `M.m[.p]`) is ≥ 6.0. Handles bare `6`,
+ * `6.0`, `6.0.1`, `7`, `10.0`, etc. Returns false on malformed input
+ * (defensive — the gate defaults to *do not drop* on missing signal).
+ */
+export function isPyYamlVersionSafeByDefault(version) {
+    const parts = version.split('.').map((s) => Number.parseInt(s, 10));
+    if (parts.length === 0 || !Number.isFinite(parts[0]))
+        return false;
+    return parts[0] >= 6;
+}
+/**
+ * Return true when the file contains an explicit unsafe `Loader=`
+ * keyword argument on a `yaml.load(...)` call at or shortly after
+ * `sinkLine`. Recognises the well-known unsafe loaders and their
+ * qualified forms:
+ *
+ *   Loader=Loader         Loader=yaml.Loader
+ *   Loader=UnsafeLoader   Loader=yaml.UnsafeLoader
+ *   Loader=FullLoader     Loader=yaml.FullLoader   (technically safer
+ *                                                   than Loader; still
+ *                                                   permits arbitrary
+ *                                                   Python object types)
+ *
+ * SafeLoader / CSafeLoader / BaseLoader / CBaseLoader are all safe and
+ * are NOT matched here.
+ *
+ * Scans `sinkLine` through the next 9 lines to catch multi-line call
+ * shapes; if the closing `)` appears before the window ends the scan
+ * stops there. Regex-based (no AST inspection) to stay consistent with
+ * the sink-filter-pass conventions and avoid pulling parse state into
+ * the gate.
+ */
+export function fileHasUnsafePyYamlLoader(sourceLines, sinkLine) {
+    const start = Math.max(0, sinkLine - 1);
+    const end = Math.min(sourceLines.length, start + 10);
+    const unsafeRe = /\bLoader\s*=\s*(?:yaml\s*\.\s*)?(?:Loader|UnsafeLoader|FullLoader)\b/;
+    for (let i = start; i < end; i++) {
+        const ln = sourceLines[i] ?? '';
+        if (unsafeRe.test(ln))
+            return true;
+        // Stop once the call closes — the `)` at the top-level. Fine
+        // approximation: any bare `)` at the START of a stripped line, or
+        // trailing `)` at end of a stripped line, signals close.
+        const stripped = ln.trim();
+        if (i > start && (stripped === ')' || stripped.endsWith(')'))) {
+            // Also test the current line before we stop, in case Loader= is
+            // on the same line as the closing paren.
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Return true when the given source text contains an in-file call that
+ * re-enables Fastjson autotype. Even a `_noneautotype` build does not
+ * protect against code that programmatically re-enables the feature
+ * (which the hardened build documents as impossible, but the classifier
+ * is a build-time strip, not a runtime lock). Defense-in-depth for the
+ * `resolveFastjsonFromPom` gate.
+ */
+export function fileReenablesFastjsonAutotype(source) {
+    if (!source)
+        return false;
+    // ParserConfig.getGlobalInstance().setAutoTypeSupport(true)
+    // ParserConfig.setAutoTypeSupport(true)   (static-import form)
+    return /\bsetAutoTypeSupport\s*\(\s*true\b/.test(source);
+}
+/**
+ * Return true when the given Java source contains a call that enables
+ * Jackson polymorphic type handling — either the legacy
+ * `enableDefaultTyping(...)` (deprecated in Jackson 2.10+ but still
+ * shipped) or the current `activateDefaultTyping(...)`.
+ *
+ * When neither is present in the file (and no `@JsonTypeInfo` is used
+ * on the target type — best-effort scan below), Jackson's default
+ * behaviour since 2.10 is safe: `ObjectMapper.readValue(json,
+ * targetType)` cannot instantiate arbitrary classes. The gate uses
+ * this to distinguish a genuine `readValue` sink from a safely-
+ * configured one.
+ *
+ * `@JsonTypeInfo` scan is intentionally file-local. A `@JsonTypeInfo`
+ * annotation on a target type in a different file would still allow
+ * polymorphic construction, but the engine treats that as unknown
+ * risk and preserves the sink (the gate only fires when the *file
+ * itself* provides positive evidence of a safe configuration).
+ */
+export function fileEnablesJacksonPolymorphism(source) {
+    if (!source)
+        return false;
+    if (/\benableDefaultTyping\s*\(/.test(source))
+        return true;
+    if (/\bactivateDefaultTyping\s*\(/.test(source))
+        return true;
+    // @JsonTypeInfo(use = Id.CLASS) / (use = Id.MINIMAL_CLASS) / (use = Id.NAME)
+    // enables polymorphic type handling on the annotated field or type.
+    // The exact `use` argument doesn't matter for the gate — any
+    // @JsonTypeInfo signals polymorphism is in play somewhere.
+    if (/@JsonTypeInfo\b/.test(source))
+        return true;
+    return false;
+}
+/**
+ * Return true when the given Java source contains a
+ * `new Yaml(new SafeConstructor(...))` or an equivalent hardened
+ * SnakeYAML constructor. When any `Yaml` instance in the file is
+ * built with the safe constructor family, we assume the file's
+ * `Yaml.load(...)` calls are safely configured; the gate then drops
+ * the deserialization sink for those calls.
+ *
+ * Recognised safe constructor classes (SnakeYAML 1.x + 2.x):
+ *   - SafeConstructor              — canonical safe loader
+ *   - SafeSchema (rare, YAML 1.2)  — safe schema-based loader
+ *
+ * Recognised safe factory calls (SnakeYAML 2.x LoaderOptions API):
+ *   - Yaml.load()   with a Constructor that extends SafeConstructor
+ *     (heuristic: any `SafeConstructor`-typed variable is safe)
+ *
+ * NOTE: A file that mixes `new Yaml(new SafeConstructor())` with
+ * `new Yaml(new Constructor(SomeClass.class))` on separate call sites
+ * would over-suppress the unsafe site. In practice this is rare (SAST
+ * teams write one wrapper per file), and the current sink-filter
+ * stage 9b handles the analogous compiled-template case with the same
+ * file-scoped heuristic. If it becomes a problem, tighten to
+ * receiver-scoped: check the specific `Yaml` receiver that carries
+ * the load() call.
+ */
+export function fileConfiguresSnakeYamlSafely(source) {
+    if (!source)
+        return false;
+    if (/\bnew\s+SafeConstructor\s*\(/.test(source))
+        return true;
+    // Explicit typed declaration form: `SafeConstructor sc = new SafeConstructor()`
+    // or `SafeConstructor sc = ...` used in a Yaml constructor.
+    if (/\bSafeConstructor\s+\w+\s*=/.test(source))
+        return true;
+    return false;
+}
+//# sourceMappingURL=dependency-versions.js.map

package/dist/analysis/dependency-versions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency-versions.js","sourceRoot":"","sources":["../../src/analysis/dependency-versions.ts"],"names":[],"mappings":"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"}

package/dist/analysis/note-coalescer.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Note-level finding coalescer — cognium-dev #143.
+ *
+ * Groups `SastFinding[]` by `(file, line)` and folds any group of two or
+ * more `level === 'note'` findings into a single record. The primary
+ * finding is picked deterministically (lexicographic `rule_id`) and
+ * the co-located rule_ids are attached as `labels[]`. Every other
+ * (`level === 'warning' | 'error'`) finding passes through untouched.
+ *
+ * Empirical basis (from the OWASP-Benchmark instrumentation capture on
+ * cognium-dev#145, comment 2026-07-03):
+ *   - 5,481 `(file, line)` locations (31.3% of files) were hit by ≥ 2
+ *     distinct advisory rules.
+ *   - Most-common pairs:
+ *       missing-public-doc + naming-convention   × 2,740
+ *       missing-csp-frame-ancestors + missing-x-frame-options × 2,740
+ *       unused-variable + variable-shadowing     (co-located)
+ *   - HIGH-severity: 0 co-locations in the same capture.
+ *
+ * Design invariants:
+ *   - Additive: consumers that key on `rule_id` continue to work
+ *     unchanged. Consumers that surface every co-located rule read
+ *     both `rule_id` and `labels`.
+ *   - Level-gated: only fires when EVERY finding in the group has
+ *     `level === 'note'`. If any group member is `warning` or `error`,
+ *     the group passes through un-coalesced — visibility of higher-
+ *     severity findings is never diminished.
+ *   - Deterministic: sort by `rule_id` inside a group before picking
+ *     the primary, so the same input always produces the same output
+ *     (test-friendly, diff-friendly, cache-friendly).
+ *   - Message preservation: the primary finding's `message` is kept
+ *     verbatim. The `labels[]` field is the sole signal that more
+ *     rules co-located there.
+ *
+ * This is the MVP of the reopen. Follow-ups on #143 include a full
+ * instrumentation rerun on multi-severity data + a broader
+ * medium-severity coalesce policy — both deferred until the data
+ * capture is redone.
+ */
+import type { SastFinding } from '../types/index.js';
+/**
+ * Coalesce note-level findings at the same `(file, line)` location.
+ * Returns a new array; the input is not mutated.
+ */
+export declare function coalesceNoteLevelFindings(findings: readonly SastFinding[]): SastFinding[];
+//# sourceMappingURL=note-coalescer.d.ts.map

package/dist/analysis/note-coalescer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"note-coalescer.d.ts","sourceRoot":"","sources":["../../src/analysis/note-coalescer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC/B,WAAW,EAAE,CAkEf"}