@clear-capabilities/agentic-security-scanner 0.185.0 → 0.186.2

package/dist/3822.index.js

@@ -1,131 +0,0 @@
-export const id = 3822;
-export const ids = [3822];
-export const modules = {
-
-/***/ 3822:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   buildArtifactProvenanceGraph: () => (/* binding */ buildArtifactProvenanceGraph),
-/* harmony export */   traceArtifactProvenanceGraph: () => (/* binding */ traceArtifactProvenanceGraph)
-/* harmony export */ });
-// PRD 5 P0 §6 — Provenance Graph: Git Commit -> Build -> OCI Digest -> SBOM
-// Component -> Finding -> Deployment.
-//
-// Naming: the exported field is `artifactProvenanceGraph` and the builder is
-// `buildArtifactProvenanceGraph` — never a bare `.provenance`/`*Provenance`,
-// per this repo's own naming discipline (5 unrelated existing uses of
-// "provenance"; see docs/implementation-status/source-to-artifact-provenance.md).
-//
-// This function does no new detection — every node/edge is assembled from
-// evidence `inventory.js`/`vuln-correlate.js` already computed. The one
-// exception is the Git-Commit edge, whose only evidence source is the
-// standard `org.opencontainers.image.revision` build label; when absent the
-// commit node is explicitly `known: false`, never inferred from git history
-// (an image's build label is the only trustworthy claim of "which commit
-// built this" — matching it against local git history by heuristic would be
-// a confident-looking guess, the exact failure mode PRD 5's signature-state
-// discipline exists to prevent elsewhere in this same PRD).
-const REVISION_LABEL = 'org.opencontainers.image.revision';
-
-function componentId(c) {
-  return c.purl || `${c.ecosystem}:${c.name}@${c.version}`;
-}
-
-/**
- * `inventory` is `inventory.js#buildImageInventory`'s `inventory`.
- * `vulnerabilities` is `vuln-correlate.js`'s `queryOSVFn` result (only
- * `type: 'vulnerable_dep'` entries become Finding nodes — the no_lockfile",
- * "unpinned_dep" structural checks don't bind to a specific component and
- * are not part of this graph). `deployment`, if supplied, is an
- * OPERATOR-DECLARED record (`{ id, environment, evidence }`) — this codebase
- * has no mechanism anywhere that discovers "which digest is running where"
- * on its own (`lineage/deployment/` models topology, not running digests),
- * so a missing `deployment` argument means the graph simply stops at the
- * OCI Digest / SBOM Component / Finding nodes, never a fabricated edge.
- */
-function buildArtifactProvenanceGraph({ inventory, vulnerabilities = [], deployment = null }) {
-  if (!inventory || typeof inventory.digest !== 'string') {
-    throw new TypeError('buildArtifactProvenanceGraph requires an inventory with a digest');
-  }
-  const nodes = [];
-  const edges = [];
-
-  const commitSha = inventory.buildLabels ? inventory.buildLabels[REVISION_LABEL] || null : null;
-  const commitId = `commit:${commitSha || 'unknown'}`;
-  const buildId = `build:${inventory.digest}`;
-  const digestId = `digest:${inventory.digest}`;
-
-  nodes.push({ id: commitId, kind: 'gitCommit', sha: commitSha, known: !!commitSha });
-  nodes.push({ id: buildId, kind: 'build', digest: inventory.digest, labels: inventory.buildLabels || {} });
-  nodes.push({ id: digestId, kind: 'ociDigest', digest: inventory.digest, digestKind: inventory.digestKind, repoTags: inventory.repoTags || [] });
-
-  edges.push({
-    from: commitId, to: buildId,
-    evidence: commitSha ? `label:${REVISION_LABEL}` : 'none',
-  });
-  edges.push({ from: buildId, to: digestId, evidence: 'same-archive' });
-
-  const components = [...(inventory.osPackages || []), ...(inventory.appPackages || [])];
-  for (const c of components) {
-    const compId = `component:${componentId(c)}`;
-    nodes.push({ id: compId, kind: 'sbomComponent', purl: c.purl || null, name: c.name, version: c.version, ecosystem: c.ecosystem });
-    edges.push({ from: digestId, to: compId, evidence: 'inventory' });
-  }
-
-  const vulnDeps = (vulnerabilities || []).filter((v) => v.type === 'vulnerable_dep');
-  for (const v of vulnDeps) {
-    const compId = `component:${v.purl || `${v.ecosystem}:${v.name}@${v.version}`}`;
-    const findingId = `finding:${v.osvId}:${v.purl || `${v.ecosystem}:${v.name}@${v.version}`}`;
-    nodes.push({ id: findingId, kind: 'finding', osvId: v.osvId, cveAliases: v.cveAliases || [], severity: v.severity });
-    edges.push({ from: compId, to: findingId, evidence: 'osv' });
-  }
-
-  if (deployment) {
-    if (typeof deployment.id !== 'string') throw new TypeError('a supplied deployment record requires an "id"');
-    const deploymentId = `deployment:${deployment.id}`;
-    nodes.push({ id: deploymentId, kind: 'deployment', environment: deployment.environment || null, declaredDigest: deployment.digest || null });
-    edges.push({
-      from: digestId, to: deploymentId,
-      evidence: deployment.evidence || 'operator-declared',
-      digestMatches: deployment.digest ? deployment.digest === inventory.digest : null,
-    });
-  }
-
-  return { nodes, edges };
-}
-
-/**
- * Walks the graph from a commit or digest to every reachable Finding/Deployment
- * node — the `provenance trace` CLI command's query surface.
- */
-function traceArtifactProvenanceGraph(graph, fromId) {
-  if (!graph || !Array.isArray(graph.nodes) || !Array.isArray(graph.edges)) {
-    throw new TypeError('traceArtifactProvenanceGraph requires a graph with nodes/edges arrays');
-  }
-  const byId = new Map(graph.nodes.map((n) => [n.id, n]));
-  if (!byId.has(fromId)) return { found: false, path: [] };
-  const adjacency = new Map();
-  for (const e of graph.edges) {
-    if (!adjacency.has(e.from)) adjacency.set(e.from, []);
-    adjacency.get(e.from).push(e);
-  }
-  const visited = new Set([fromId]);
-  const queue = [fromId];
-  const reached = [];
-  while (queue.length) {
-    const cur = queue.shift();
-    for (const e of adjacency.get(cur) || []) {
-      if (visited.has(e.to)) continue;
-      visited.add(e.to);
-      reached.push({ node: byId.get(e.to), via: e });
-      queue.push(e.to);
-    }
-  }
-  return { found: true, root: byId.get(fromId), reached };
-}
-
-
-/***/ })
-
-};

package/dist/3868.index.js

@@ -1,292 +0,0 @@
-export const id = 3868;
-export const ids = [3868];
-export const modules = {
-
-/***/ 33868:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   MEMORY_PROFILES: () => (/* binding */ MEMORY_PROFILES),
-/* harmony export */   capabilitiesFromFamilyHint: () => (/* binding */ capabilitiesFromFamilyHint),
-/* harmony export */   classifyModelFamily: () => (/* binding */ classifyModelFamily),
-/* harmony export */   detectMemoryTier: () => (/* binding */ detectMemoryTier),
-/* harmony export */   detectSystemMemory: () => (/* binding */ detectSystemMemory),
-/* harmony export */   recommendAdmission: () => (/* binding */ recommendAdmission)
-/* harmony export */ });
-/* unused harmony exports KNOWN_MODEL_SIZE_GB, evaluateMemoryAdmission */
-/* harmony import */ var node_os__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(48161);
-/* harmony import */ var _oom_feedback_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(67181);
-// Model family hints, RAM-aware memory profiles, and the memory-admission
-// check for the Ollama provider (agentic-security-ollama-offline-prd.md
-// §13, §14, §15, §22.3, §30).
-//
-// FAMILY HINTS ARE DEFAULTS, NEVER AUTHORITY (PRD §12/§13). A name like
-// `gemma4:e2b` tells us nothing Ollama itself won't confirm — it only lets the
-// harness suggest a sane default before any network call. If a model actually
-// installed under a family-hinted name lacks a capability the hint implied,
-// the runtime probe (model-probe.js, added when tool-calling/structured-output
-// probing lands) always wins. This module only classifies and estimates; it
-// never asserts a capability is present.
-//
-// MEMORY NUMBERS ARE ESTIMATES, NOT PROMISES (PRD §22.3, §14.1). Ollama
-// artifact sizes and this module's headroom reserves are best-effort figures
-// sourced from what Ollama currently publishes; they exist so the harness can
-// fail BEFORE an OS-level OOM, not so it can claim an exact answer. Every
-// admission decision leaves a stated safety margin rather than trying to pack
-// memory to the byte.
-
-
-
-
-// PRD §12/§13 FR-1203 — non-authoritative family hint from a model name.
-// Longest/most-specific pattern first so `qwen3.5:4b` doesn't fall through to
-// the bare `qwen` bucket.
-const FAMILY_PATTERNS = [
-  [/^qwen3\.5/i, 'qwen3.5'],
-  [/^qwen3-coder-next/i, 'qwen3-coder-next'],
-  [/^qwen3-coder/i, 'qwen3-coder'],
-  [/^qwen2\.5-coder/i, 'qwen2.5-coder'],
-  [/^qwen3/i, 'qwen3'],
-  [/^qwen/i, 'qwen'],
-  [/^gemma4/i, 'gemma4'],
-  [/^functiongemma/i, 'functiongemma'],
-  [/^gemma3/i, 'gemma3'],
-  [/^gemma/i, 'gemma'],
-];
-
-/** Non-authoritative family classification for defaults/messaging only. */
-function classifyModelFamily(modelName) {
-  const name = String(modelName || '').trim();
-  for (const [re, family] of FAMILY_PATTERNS) if (re.test(name)) return family;
-  return 'unknown';
-}
-
-// PRD §13.1 — non-authoritative defaults per family, overridden by any real
-// runtime probe result (model-probe.js). `tools`/`structuredJson`/`thinking`
-// are 'unknown' where Ollama's own behavior varies by specific tag/quant
-// rather than by family alone.
-const FAMILY_CAPABILITY_HINTS = {
-  'qwen3.5': { chat: true, structuredJson: true, tools: true, thinking: 'unknown' },
-  qwen3: { chat: true, structuredJson: true, tools: true, thinking: 'unknown' },
-  'qwen3-coder': { chat: true, structuredJson: true, tools: true, thinking: false },
-  'qwen3-coder-next': { chat: true, structuredJson: true, tools: true, thinking: false },
-  'qwen2.5-coder': { chat: true, structuredJson: true, tools: 'unknown', thinking: false },
-  qwen: { chat: true, structuredJson: 'unknown', tools: 'unknown', thinking: 'unknown' },
-  gemma4: { chat: true, structuredJson: true, tools: true, thinking: 'unknown' },
-  functiongemma: { chat: true, structuredJson: 'unknown', tools: true, thinking: false },
-  gemma3: { chat: true, structuredJson: true, tools: false, thinking: false },
-  gemma: { chat: true, structuredJson: 'unknown', tools: 'unknown', thinking: 'unknown' },
-  unknown: { chat: true, structuredJson: 'unknown', tools: 'unknown', thinking: 'unknown' },
-};
-
-/**
- * Build the PRD §13.1 ModelCapabilities object from a family hint alone
- * (Layer B). Layer A (Ollama's own /api/show metadata) and Layer C (runtime
- * probes) are applied by the caller and override these fields — this
- * function only ever sets `source.familyHint: true`.
- */
-function capabilitiesFromFamilyHint(modelName) {
-  const family = classifyModelFamily(modelName);
-  const hint = FAMILY_CAPABILITY_HINTS[family] || FAMILY_CAPABILITY_HINTS.unknown;
-  return {
-    chat: hint.chat,
-    structuredJson: hint.structuredJson,
-    tools: hint.tools,
-    thinking: hint.thinking,
-    vision: false,
-    contextTokens: undefined,
-    source: { metadata: false, familyHint: true, runtimeProbe: false },
-  };
-}
-
-// ── RAM-aware memory profiles (PRD §14.4, §15.2, §22.3, §30) ───────────────
-
-const MB = 1024 * 1024;
-const GB = 1024 * MB;
-
-// Best-effort artifact sizes as currently distributed by Ollama, used only to
-// pick a SENSIBLE STARTING recommendation — the real admission decision below
-// uses actually-free memory, not this table. Keep in sync with the PRD's own
-// cited figures; a stale entry only affects the suggested default, never the
-// admission math (which reads real os.freemem()).
-const KNOWN_MODEL_SIZE_GB = Object.freeze({
-  'qwen3.5:2b': 1.7,
-  'qwen3.5:4b': 3.4,
-  'qwen3.5:9b': 6.6,
-  'gemma4:e2b': 7.2,
-  'gemma4:12b': 7.6,
-  'gemma4:latest': 9.6,
-});
-
-/** PRD §30 profile presets. `auto` picks between these by detected RAM. */
-const MEMORY_PROFILES = Object.freeze({
-  '8gb': {
-    label: '8gb',
-    preferredModel: 'qwen3.5:4b',
-    fallbackModel: 'qwen3.5:2b',
-    initialContextTokens: 4096,
-    targetContextTokens: 8192,
-    maxConcurrency: 1,
-    minFreeRamMb: 1536,
-  },
-  '16gb-qwen': {
-    label: '16gb-qwen',
-    preferredModel: 'qwen3.5:9b',
-    fallbackModel: 'qwen3.5:4b',
-    initialContextTokens: 16384,
-    targetContextTokens: 32768,
-    maxConcurrency: 1,
-    minFreeRamMb: 2048,
-  },
-  '16gb-gemma': {
-    label: '16gb-gemma',
-    preferredModel: 'gemma4:e2b',
-    fallbackModel: 'qwen3.5:4b',
-    initialContextTokens: 8192,
-    targetContextTokens: 16384,
-    maxConcurrency: 1,
-    minFreeRamMb: 2048,
-  },
-});
-
-/**
- * PRD §22.3 — detect total/available system RAM. Thin wrapper over `os` so
- * tests can inject fake values without mocking the `os` module globally.
- */
-function detectSystemMemory({ totalBytes, freeBytes } = {}) {
-  return {
-    totalBytes: Number.isFinite(totalBytes) ? totalBytes : node_os__WEBPACK_IMPORTED_MODULE_0__.totalmem(),
-    freeBytes: Number.isFinite(freeBytes) ? freeBytes : node_os__WEBPACK_IMPORTED_MODULE_0__.freemem(),
-  };
-}
-
-/**
- * Pick the RAM tier ('8gb' | '16gb') a machine falls into. Anything under
- * ~9 GB total is treated as the 8 GB tier — real "8 GB" machines report
- * slightly less than 8*1024^3 bytes to userspace (firmware/GPU reservations),
- * so a hard `< 8*GB` cutoff would misclassify real 8 GB hardware as unknown.
- */
-function detectMemoryTier(totalBytes) {
-  if (!Number.isFinite(totalBytes) || totalBytes <= 0) return 'unknown';
-  if (totalBytes < 9 * GB) return '8gb';
-  return '16gb';
-}
-
-/**
- * PRD §22.3 admission algorithm: does `contextTokens` at `model` fit in
- * currently-free memory with the configured reserve intact?
- *
- * This is deliberately conservative and coarse (PRD "avoid pretending memory
- * estimates are exact"): model residency is estimated from KNOWN_MODEL_SIZE_GB
- * when available (falling back to a pessimistic 8 GB assumption for an
- * unrecognized tag so an unknown model never LOOKS safer than a known large
- * one), and KV-cache growth is approximated as a fixed per-1K-token cost
- * rather than modeled per-architecture — real KV cache size depends on layer
- * count/head count/quantization the harness cannot know without Ollama's own
- * runtime numbers.
- */
-const ESTIMATED_KV_CACHE_MB_PER_1K_TOKENS = 32; // conservative, model-independent approximation
-const RUNTIME_OVERHEAD_MB = 512; // Ollama server + OS scheduler slack, independent of model size
-
-function evaluateMemoryAdmission({
-  modelName,
-  contextTokens,
-  freeBytes,
-  minFreeRamMb,
-  modelSizeGb,
-} = {}) {
-  const sizeGb = Number.isFinite(modelSizeGb) ? modelSizeGb : (KNOWN_MODEL_SIZE_GB[modelName] ?? 8);
-  const modelMb = sizeGb * 1024;
-  const kvCacheMb = (Number(contextTokens) || 0) / 1000 * ESTIMATED_KV_CACHE_MB_PER_1K_TOKENS;
-  const requiredMb = modelMb + kvCacheMb + RUNTIME_OVERHEAD_MB + (Number(minFreeRamMb) || 0);
-  const freeMb = (Number(freeBytes) || 0) / MB;
-  const admitted = freeMb >= requiredMb;
-  return {
-    admitted,
-    freeMb: Math.round(freeMb),
-    requiredMb: Math.round(requiredMb),
-    modelEstimateMb: Math.round(modelMb),
-    kvCacheEstimateMb: Math.round(kvCacheMb),
-    reserveMb: Number(minFreeRamMb) || 0,
-  };
-}
-
-/**
- * Full recommendation flow (PRD §22 "Memory admission algorithm"):
- * try the profile's preferred context, shrink it, then fall back to the
- * profile's smaller model, before ever declaring the profile unusable.
- * Never recommends cloud — the worst outcome this function can return is
- * `{admitted:false}` with a human-readable explanation, which callers treat
- * as "run deterministic-only" (PRD §23.4).
- */
-function recommendAdmission(opts = {}) {
-  const result = _recommendAdmissionCore(opts);
-  // Adversarial-review fix (2026-09): a memory-admission ESTIMATE that
-  // actually caused a real OOM (ollama-provider.js's callOllamaChat now
-  // records this via oom-feedback.js) used to have no way to affect a
-  // future admission decision for the SAME model on the SAME machine — the
-  // exact same "admitted: true" would repeat forever. This does not
-  // recalibrate the underlying estimate (that needs real hardware variety
-  // one machine's observed failures can't substitute for); it attaches an
-  // honest warning so the decision is no longer presented with unqualified
-  // confidence.
-  const chosenModel = result.model || opts.requestedModel;
-  const prior = chosenModel ? (0,_oom_feedback_js__WEBPACK_IMPORTED_MODULE_1__/* .priorOOMFor */ .NL)(chosenModel) : null;
-  if (prior) {
-    return {
-      ...result,
-      priorOOMWarning: `'${chosenModel}' has previously failed with an out-of-memory error on this machine ` +
-        `(${prior.count} time${prior.count === 1 ? '' : 's'}, most recently ${new Date(prior.lastAt).toISOString()}). ` +
-        'The memory estimate below may be optimistic for your hardware.',
-    };
-  }
-  return result;
-}
-
-function _recommendAdmissionCore({ profile, freeBytes, requestedContextTokens, requestedModel } = {}) {
-  const p = MEMORY_PROFILES[profile];
-  if (!p) return { admitted: false, reason: `unknown memory profile '${profile}'` };
-
-  const model = requestedModel || p.preferredModel;
-  const attempts = [];
-
-  // 1. Requested (or target) context at the requested/preferred model.
-  const primaryContext = Number.isFinite(requestedContextTokens) ? requestedContextTokens : p.targetContextTokens;
-  let check = evaluateMemoryAdmission({ modelName: model, contextTokens: primaryContext, freeBytes, minFreeRamMb: p.minFreeRamMb });
-  attempts.push({ model, contextTokens: primaryContext, ...check });
-  if (check.admitted) return { admitted: true, model, contextTokens: primaryContext, attempts };
-
-  // 2. Reduce context to the profile's conservative initial value first —
-  //    PRD FR-2104: "shrink context before declaring an otherwise compatible
-  //    model unusable."
-  if (primaryContext !== p.initialContextTokens) {
-    check = evaluateMemoryAdmission({ modelName: model, contextTokens: p.initialContextTokens, freeBytes, minFreeRamMb: p.minFreeRamMb });
-    attempts.push({ model, contextTokens: p.initialContextTokens, ...check });
-    if (check.admitted) return { admitted: true, model, contextTokens: p.initialContextTokens, attempts, reducedContext: true };
-  }
-
-  // 3. Fall back to the profile's smaller model at its initial context.
-  if (p.fallbackModel && p.fallbackModel !== model) {
-    check = evaluateMemoryAdmission({ modelName: p.fallbackModel, contextTokens: p.initialContextTokens, freeBytes, minFreeRamMb: p.minFreeRamMb });
-    attempts.push({ model: p.fallbackModel, contextTokens: p.initialContextTokens, ...check });
-    if (check.admitted) {
-      return {
-        admitted: true, model: p.fallbackModel, contextTokens: p.initialContextTokens, attempts,
-        reducedContext: true, fellBackToSmallerModel: true,
-      };
-    }
-  }
-
-  // 4. Nothing fits — deterministic-only, never cloud.
-  return {
-    admitted: false,
-    attempts,
-    reason: `No local model/context combination fit in available memory with the configured reserve. ` +
-      `Recommend deterministic-only scanning, or free memory before retrying.`,
-  };
-}
-
-
-/***/ })
-
-};

package/dist/3918.index.js

@@ -1,192 +0,0 @@
-export const id = 3918;
-export const ids = [3918];
-export const modules = {
-
-/***/ 63918:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   evaluatePolicy: () => (/* binding */ evaluatePolicy)
-/* harmony export */ });
-/* unused harmony export _internals */
-/* harmony import */ var node_fs__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(73024);
-/* harmony import */ var node_child_process__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(31421);
-// Policy-as-code gate (FR-SDLC-9).
-//
-// Today's CI gate is `--fail-on <severity>`. That's coarse. Customers want
-// to write nuanced rules: "fail if any sql-injection finding has
-// confidence ≥ 0.8 AND the file is under src/api/", or "fail if total
-// exploitability score across critical findings exceeds 5".
-//
-// We support two modes:
-//
-//   1. EXTERNAL OPA: if the `opa` binary is on PATH and `--policy <file.rego>`
-//      is supplied, we shell out to `opa eval -d <file> -i <findings.json>
-//      "data.<package>.deny"`. This is the right answer for customers who
-//      already use OPA elsewhere.
-//
-//   2. EMBEDDED MINI: when no opa binary is available, fall back to a tiny
-//      DSL that's a strict subset of rego. Rules read top-level
-//      `package`/`deny` blocks; each `deny` is a JS-evaluable expression
-//      over findings[]. This lets the v1 ship without an external binary
-//      dep while documenting the upgrade path.
-
-
-
-
-// ─── External OPA ─────────────────────────────────────────────────────────
-
-function _haveOpa() {
-  try {
-    const r = (0,node_child_process__WEBPACK_IMPORTED_MODULE_1__.spawnSync)('opa', ['version'], { stdio: 'ignore', timeout: 3000 });
-    return r.status === 0;
-  } catch { return false; }
-}
-
-function _runOpa(policyFile, findingsJsonPath, packageName) {
-  const r = (0,node_child_process__WEBPACK_IMPORTED_MODULE_1__.spawnSync)('opa', [
-    'eval', '-d', policyFile, '-i', findingsJsonPath,
-    `data.${packageName}.deny`,
-  ], { encoding: 'utf8', timeout: 10_000 });
-  if (r.error) return { ok: false, reason: `opa-error:${r.error.code || r.error.message}` };
-  if (r.status !== 0) return { ok: false, reason: `opa-exit:${r.status}`, stderr: r.stderr };
-  try {
-    const parsed = JSON.parse(r.stdout);
-    const result = parsed.result?.[0]?.expressions?.[0]?.value;
-    return { ok: true, denials: Array.isArray(result) ? result : [] };
-  } catch (e) {
-    return { ok: false, reason: `opa-output-parse:${e.message}` };
-  }
-}
-
-// ─── Embedded mini DSL ────────────────────────────────────────────────────
-//
-// Rego is too big to reimplement. We support a tiny shape:
-//
-//   # POLICY: agentic-security policy-gate v1
-//   deny[msg] {
-//     finding := input.findings[_]
-//     finding.severity == "critical"
-//     msg := sprintf("critical finding: %v at %v", [finding.vuln, finding.file])
-//   }
-//
-// Parser strategy: extract each `deny[msg] { ... }` block; translate the
-// body to a JS predicate. The grammar we accept is:
-//
-//   - `<lhs> == <value>` / `<lhs> != <value>` / `<lhs> > <num>` / `<lhs> < <num>`
-//   - `<lhs>` references `finding.<field>` or `input.<field>`
-//   - `msg := "..."` or `msg := sprintf("...", [args])` — the msg literal
-//   - newlines + `;` as separators
-//
-// Anything more complex requires the external OPA binary.
-
-function _parseEmbedded(policyText) {
-  const blocks = [];
-  // Match each `deny[NAME] { ... }` block (or `deny { ... }`).
-  const blockRe = /\bdeny(?:\s*\[\s*(\w+)\s*\])?\s*\{([\s\S]*?)\}/g;
-  let m;
-  while ((m = blockRe.exec(policyText))) {
-    const body = m[2];
-    const conditions = [];
-    let msgExpr = `"policy violation"`;
-    for (const line of body.split(/[\n;]/)) {
-      const ln = line.trim();
-      if (!ln || ln.startsWith('#')) continue;
-      // Assignment: `<id> := <expr>`
-      const asn = ln.match(/^(\w+)\s*:=\s*(.+)$/);
-      if (asn && asn[1] !== 'msg') continue;  // skip non-msg assignments
-      if (asn && asn[1] === 'msg') { msgExpr = asn[2].trim(); continue; }
-      // Comparison: `finding.<field> <op> <value>`
-      const cmp = ln.match(/^(finding|input)\.([a-zA-Z_][\w.]*)\s*(==|!=|<=|>=|<|>)\s*(.+)$/);
-      if (!cmp) continue;
-      const [, scope, field, op, valueRaw] = cmp;
-      let value = valueRaw.trim();
-      if (/^".*"$/.test(value)) value = JSON.stringify(value.slice(1, -1));
-      conditions.push({ scope, field, op, value });
-    }
-    blocks.push({ conditions, msgExpr });
-  }
-  return blocks;
-}
-
-function _evalBlock(block, finding) {
-  for (const c of block.conditions) {
-    const lhs = _resolvePath(finding, c.field);
-    let rhs;
-    try { rhs = JSON.parse(c.value); }
-    catch { rhs = c.value.replace(/^"|"$/g, ''); }
-    if (c.op === '==' && lhs !==  rhs) return null;
-    if (c.op === '!=' && lhs === rhs) return null;
-    if (c.op === '>'  && !(Number(lhs)  > Number(rhs))) return null;
-    if (c.op === '<'  && !(Number(lhs)  < Number(rhs))) return null;
-    if (c.op === '>=' && !(Number(lhs) >= Number(rhs))) return null;
-    if (c.op === '<=' && !(Number(lhs) <= Number(rhs))) return null;
-  }
-  return _renderMsg(block.msgExpr, finding);
-}
-
-function _resolvePath(obj, dotPath) {
-  return dotPath.split('.').reduce((o, k) => (o == null ? undefined : o[k]), obj);
-}
-
-function _renderMsg(expr, finding) {
-  // Strip outer quotes if string literal.
-  const m = expr.match(/^["'](.+)["']$/);
-  if (m) return m[1];
-  // sprintf shape: sprintf("...", [a, b])
-  const sf = expr.match(/^sprintf\s*\(\s*"([^"]+)"\s*,\s*\[(.+)\]\s*\)$/);
-  if (sf) {
-    const fmt = sf[1];
-    const args = sf[2].split(',').map(s => _resolvePath(finding, s.trim().replace(/^finding\./, '')));
-    let i = 0;
-    return fmt.replace(/%v/g, () => String(args[i++] ?? ''));
-  }
-  return expr;
-}
-
-function _runEmbedded(policyText, findings) {
-  const blocks = _parseEmbedded(policyText);
-  const denials = [];
-  for (const f of findings) {
-    for (const b of blocks) {
-      const msg = _evalBlock(b, f);
-      if (msg) denials.push(msg);
-    }
-  }
-  return { ok: true, denials };
-}
-
-// ─── Public API ────────────────────────────────────────────────────────────
-
-/**
- * Evaluate a policy file against the findings list.
- * Returns { ok, denials, runner } — denials is an array of human-readable
- * strings (one per violation). When denials.length > 0, the gate fails.
- */
-function evaluatePolicy(policyPath, findings, opts = {}) {
-  if (!policyPath || !node_fs__WEBPACK_IMPORTED_MODULE_0__.existsSync(policyPath)) {
-    return { ok: false, reason: 'policy-file-missing' };
-  }
-  const policyText = node_fs__WEBPACK_IMPORTED_MODULE_0__.readFileSync(policyPath, 'utf8');
-  const useExternal = !opts.embeddedOnly && _haveOpa();
-  if (useExternal) {
-    // Write findings to a temp file the opa binary reads.
-    const tmp = `/tmp/as-policy-${Date.now()}.json`;
-    node_fs__WEBPACK_IMPORTED_MODULE_0__.writeFileSync(tmp, JSON.stringify({ findings }));
-    const pkgMatch = policyText.match(/^\s*package\s+([\w.]+)/m);
-    const pkg = pkgMatch ? pkgMatch[1] : 'main';
-    const r = _runOpa(policyPath, tmp, pkg);
-    try { node_fs__WEBPACK_IMPORTED_MODULE_0__.unlinkSync(tmp); } catch {}
-    if (r.ok) return { ...r, runner: 'opa' };
-    // Fall through to embedded on opa error.
-  }
-  const r = _runEmbedded(policyText, findings);
-  return { ...r, runner: 'embedded' };
-}
-
-const _internals = { _parseEmbedded, _evalBlock, _runEmbedded };
-
-
-/***/ })
-
-};