@backbencher/brain 0.0.0-stage → 0.1.1

package/dist/brain-relationship-enrichment-MYR2AM4F.js

@@ -0,0 +1,558 @@
+import {
+  BrainDatabase
+} from "./chunk-QKTRECYS.js";
+import {
+  create
+} from "./chunk-BQ3OVQ3P.js";
+import "./chunk-2BSKD7O3.js";
+import {
+  isTestFileCandidate
+} from "./chunk-L5TDYKYK.js";
+import "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+
+// src/brain/brain-relationship-enrichment.ts
+var log = create({ service: "relationship-enrichment" });
+var ENRICHMENT_MAX_ROWS = 2e6;
+var BATCH = 2e4;
+var CRITICALITY_HIGH_MIN_IN_DEGREE = 50;
+var CRITICALITY_MEDIUM_MIN_IN_DEGREE = 10;
+var UNRESOLVED_TARGET = "unresolved";
+function resolveMaxRows(explicit) {
+  if (explicit !== void 0 && explicit !== null) {
+    const n = Number(explicit);
+    if (n === Infinity) return Infinity;
+    if (Number.isFinite(n) && n > 0) return Math.trunc(n);
+    return ENRICHMENT_MAX_ROWS;
+  }
+  const raw = process.env.BB_ENRICHMENT_MAX_ROWS;
+  if (raw !== void 0 && raw !== "") {
+    const n = Number(raw);
+    if (n === Infinity) return Infinity;
+    if (Number.isFinite(n) && n > 0) return Math.trunc(n);
+  }
+  return ENRICHMENT_MAX_ROWS;
+}
+async function enrichRelationships(projectId, onProgress, opts = {}) {
+  const startTime = Date.now();
+  const rawDb = await BrainDatabase.getRawInstance(projectId);
+  const now = Date.now();
+  const maxRows = resolveMaxRows(opts.maxRows);
+  const report = (step, pct) => {
+    if (onProgress) onProgress(step, pct);
+  };
+  report("reading", 0);
+  const zero = (pagination2) => ({
+    enriched: 0,
+    patternsFound: 0,
+    durationMs: 0,
+    considered: 0,
+    unchanged: 0,
+    danglingSources: 0,
+    unresolvedTargets: 0,
+    danglingTargets: 0,
+    rowsWithoutParseableMetadata: 0,
+    failedPages: 0,
+    failedRows: 0,
+    firstError: null,
+    truncated: false,
+    skipped: 0,
+    cap: maxRows,
+    pagination: pagination2,
+    staleInScope: 0
+  });
+  const countRow = rawDb.prepare(`
+    SELECT COUNT(*) as c FROM brain_relationship WHERE project_id = ?
+  `).get(projectId);
+  const totalRels = countRow?.c ?? 0;
+  let rowidAvailable = true;
+  try {
+    rawDb.prepare(`SELECT rowid FROM brain_relationship LIMIT 1`).get();
+  } catch {
+    rowidAvailable = false;
+  }
+  const pagination = rowidAvailable ? "rowid" : "offset";
+  if (totalRels === 0) {
+    report("done", 100);
+    return { ...zero(pagination), durationMs: Date.now() - startTime };
+  }
+  report("counting", 0);
+  const inDegreeMap = /* @__PURE__ */ new Map();
+  const inDegreeRows = rawDb.prepare(`
+    SELECT target_symbol_id, COUNT(*) as c
+    FROM brain_relationship
+    WHERE project_id = ? AND target_symbol_id IS NOT NULL AND target_symbol_id != ''
+    GROUP BY target_symbol_id
+  `).all(projectId);
+  for (const r of inDegreeRows) {
+    inDegreeMap.set(r.target_symbol_id, r.c);
+  }
+  report("enriching", 5);
+  const scopeIds = opts.sourceSymbolIds;
+  const danglingRow = rawDb.prepare(`
+    SELECT COUNT(*) as c FROM brain_relationship r
+    WHERE r.project_id = ?
+      AND NOT EXISTS (SELECT 1 FROM brain_symbol s WHERE s.id = r.source_symbol_id)
+  `).get(projectId);
+  let danglingSources = danglingRow?.c ?? 0;
+  if (danglingSources > 0) {
+    log.warn("relationship enrichment: dangling source edges cannot be enriched", {
+      projectId: String(projectId).slice(0, 8),
+      danglingSources,
+      totalRelationships: totalRels
+    });
+  }
+  let danglingTargets = 0;
+  try {
+    const row = rawDb.prepare(`
+      SELECT COUNT(*) as c FROM brain_relationship r
+      WHERE r.project_id = ? AND r.target_symbol_id IS NOT NULL AND r.target_symbol_id != ''
+        AND NOT EXISTS (SELECT 1 FROM brain_symbol t WHERE t.id = r.target_symbol_id)
+    `).get(projectId);
+    danglingTargets = row?.c ?? 0;
+  } catch (e) {
+    log.warn("relationship enrichment: dangling-target count unavailable", { error: e?.message });
+  }
+  const updateStmt = rawDb.prepare(`
+    UPDATE brain_relationship SET metadata = ? WHERE id = ? AND project_id = ?
+  `);
+  const ENRICHMENT_OWNED_KEYS = /* @__PURE__ */ new Set([
+    "role",
+    "pattern",
+    "layerFlow",
+    "criticality",
+    "frequency",
+    "isTestCode",
+    "isGeneratedCode",
+    "isFrameworkContract",
+    "isDependencyInjection",
+    "inferredAt"
+  ]);
+  let rowsWithoutParseableMetadata = 0;
+  let considered = 0;
+  let unchanged = 0;
+  let unresolvedTargets = 0;
+  let enriched = 0;
+  let patternsFound = 0;
+  let failedPages = 0;
+  let failedRows = 0;
+  let firstError = null;
+  let staleInScope = 0;
+  const sameMetadata = (a, b) => {
+    const strip = (m) => {
+      const out = {};
+      for (const k of Object.keys(m)) if (k !== "inferredAt") out[k] = m[k];
+      return out;
+    };
+    const ak = Object.keys(strip(a)).sort();
+    const bk = Object.keys(strip(b)).sort();
+    if (ak.length !== bk.length) return false;
+    for (let i = 0; i < ak.length; i++) {
+      if (ak[i] !== bk[i]) return false;
+      if (JSON.stringify(strip(a)[ak[i]]) !== JSON.stringify(strip(b)[bk[i]])) return false;
+    }
+    return true;
+  };
+  const mergeMetadata = (row, computed) => {
+    let existing = {};
+    if (typeof row.metadata === "string" && row.metadata.length > 0) {
+      try {
+        const parsed = JSON.parse(row.metadata);
+        if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) existing = parsed;
+        else rowsWithoutParseableMetadata++;
+      } catch {
+        rowsWithoutParseableMetadata++;
+      }
+    }
+    const meta = { ...existing };
+    for (const k of Object.keys(meta)) if (ENRICHMENT_OWNED_KEYS.has(k)) delete meta[k];
+    meta.layerFlow = computed.layerFlow;
+    meta.criticality = computed.criticality;
+    meta.frequency = computed.frequency;
+    if (computed.isTestCode) meta.isTestCode = true;
+    if (computed.isGeneratedCode) meta.isGeneratedCode = true;
+    if (computed.isFrameworkContract) meta.isFrameworkContract = true;
+    if (computed.isDI) meta.isDependencyInjection = true;
+    if (computed.pattern) meta.pattern = computed.pattern;
+    if (computed.role) meta.role = computed.role;
+    meta.inferredAt = now;
+    return { meta, existing };
+  };
+  const processBatch = (batch) => {
+    if (batch.length === 0) return { written: 0, patterns: 0, failed: null };
+    let written = 0;
+    let patterns = 0;
+    let unresolvedHere = 0;
+    let failed = null;
+    const tx = rawDb.transaction((rows) => {
+      for (const row of rows) {
+        const sourceFile = row.source_file || "";
+        const sourceLanguage = row.source_language || null;
+        const isTestCode = sourceLanguage ? isTestFileCandidate(sourceFile, sourceLanguage) : isTestFileCandidate(sourceFile);
+        const isGeneratedCode = sourceFile.includes("/generated/") || sourceFile.includes("/build/generated/") || sourceFile.includes(".pb.") || sourceFile.includes(".g.dart") || sourceFile.includes(".g.cs") || sourceFile.includes("/gen/");
+        const isFrameworkContract = row.relationship_type === "extends" || row.relationship_type === "overrides" || row.relationship_type === "implements";
+        const isDI = row.relationship_type === "instantiates" && (row.target_type === "interface" || row.target_type === "trait" || row.target_type === "protocol" || row.target_type === "abstract");
+        const targetResolved = typeof row.target_resolved_id === "string" && row.target_resolved_id.length > 0;
+        if (!targetResolved) unresolvedHere++;
+        const layerFlow = `${row.source_layer || "core"}\u2192${targetResolved && row.target_layer ? row.target_layer : UNRESOLVED_TARGET}`;
+        const inDeg = inDegreeMap.get(row.target_symbol_id) ?? 0;
+        const criticality = inDeg >= CRITICALITY_HIGH_MIN_IN_DEGREE ? "high" : inDeg >= CRITICALITY_MEDIUM_MIN_IN_DEGREE ? "medium" : "low";
+        const frequency = `one_of_${inDeg}`;
+        const pattern = inferPattern({
+          relationship_type: row.relationship_type,
+          source_name: row.source_name || "",
+          source_type: row.source_type || "",
+          target_name: row.target_name || "",
+          target_type: row.target_type || "",
+          source_file: row.source_file || ""
+        });
+        const role = inferRole(row.relationship_type, row.source_type || "", row.target_type || "", pattern);
+        const { meta, existing } = mergeMetadata(row, {
+          layerFlow,
+          criticality,
+          frequency,
+          isTestCode,
+          isGeneratedCode,
+          isFrameworkContract,
+          isDI,
+          pattern,
+          role
+        });
+        if (sameMetadata(existing, meta)) continue;
+        updateStmt.run(JSON.stringify(meta), row.id, projectId);
+        written++;
+        if (pattern) patterns++;
+      }
+    });
+    try {
+      tx(batch);
+    } catch (e) {
+      failed = e?.message ? String(e.message) : String(e);
+      written = 0;
+      patterns = 0;
+      unresolvedHere = 0;
+    }
+    unresolvedTargets += unresolvedHere;
+    return { written, patterns, failed };
+  };
+  let truncated = false;
+  const processedSoFar = () => enriched + unchanged + failedRows;
+  const absorb = (batch, make) => {
+    let outcome = make();
+    if (outcome.failed !== null) outcome = make();
+    const rowsInPage = batch.length;
+    considered += rowsInPage;
+    if (outcome.failed === null) {
+      enriched += outcome.written;
+      patternsFound += outcome.patterns;
+      unchanged += rowsInPage - outcome.written;
+      return true;
+    }
+    failedPages++;
+    failedRows += rowsInPage;
+    if (firstError === null) firstError = outcome.failed;
+    log.warn("relationship enrichment: page failed, rows left un-enriched", {
+      projectId: String(projectId).slice(0, 8),
+      rows: rowsInPage,
+      error: outcome.failed
+    });
+    return false;
+  };
+  const PROJECTION = `
+             r.id, r.rowid AS rowid, r.relationship_type, r.source_symbol_id, r.target_symbol_id, r.metadata,
+             s.layer as source_layer, s.symbol_type as source_type, s.name as source_name,
+             t.id as target_resolved_id, t.layer as target_layer, t.symbol_type as target_type, t.name as target_name,
+             sf.relative_path as source_file, sf.language as source_language`;
+  const JOINS = `
+      JOIN brain_symbol s ON s.id = r.source_symbol_id AND s.project_id = r.project_id
+      LEFT JOIN brain_symbol t ON t.id = r.target_symbol_id AND t.project_id = r.project_id
+      LEFT JOIN brain_file sf ON sf.id = s.file_id`;
+  if (scopeIds?.length) {
+    const CHUNK = 500;
+    for (let i = 0; i < scopeIds.length; i += CHUNK) {
+      if (maxRows !== Infinity && processedSoFar() >= maxRows) {
+        truncated = true;
+        break;
+      }
+      const chunk = scopeIds.slice(i, i + CHUNK);
+      const placeholders = chunk.map(() => "?").join(",");
+      const batch = rawDb.prepare(`
+      SELECT ${PROJECTION}
+      FROM brain_relationship r
+      ${JOINS}
+      WHERE r.project_id = ? AND r.source_symbol_id IN (${placeholders})
+    `).all(projectId, ...chunk);
+      absorb(batch, () => processBatch(batch));
+      const pct = Math.min(95, 5 + Math.round(processedSoFar() / Math.max(1, scopeIds.length) * 90));
+      report("enriching", pct);
+    }
+    staleInScope = countStaleInScope(rawDb, projectId, scopeIds);
+  } else {
+    if (pagination === "rowid") {
+      let cursor = 0;
+      for (; ; ) {
+        const remaining = maxRows === Infinity ? BATCH : Math.min(BATCH, maxRows - processedSoFar());
+        if (remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        const batch = rawDb.prepare(`
+      SELECT ${PROJECTION}
+      FROM brain_relationship r
+      ${JOINS}
+      WHERE r.project_id = ? AND r.rowid > ?
+      ORDER BY r.rowid
+      LIMIT ${remaining}
+    `).all(projectId, cursor);
+        if (batch.length === 0) break;
+        const pageLast = batch[batch.length - 1].rowid;
+        absorb(batch, () => processBatch(batch));
+        cursor = pageLast;
+        const pct = Math.min(95, 5 + Math.round(processedSoFar() / Math.max(1, totalRels) * 90));
+        report("enriching", pct);
+      }
+    } else {
+      let offset = 0;
+      for (; ; ) {
+        const remaining = maxRows === Infinity ? BATCH : Math.min(BATCH, maxRows - processedSoFar());
+        if (remaining <= 0) {
+          truncated = true;
+          break;
+        }
+        const batch = rawDb.prepare(`
+      SELECT ${PROJECTION}
+      FROM brain_relationship r
+      ${JOINS}
+      WHERE r.project_id = ?
+      LIMIT ${remaining} OFFSET ${offset}
+    `).all(projectId);
+        if (batch.length === 0) break;
+        absorb(batch, () => processBatch(batch));
+        offset += batch.length;
+        const pct = Math.min(95, 5 + Math.round(offset / Math.max(1, totalRels) * 90));
+        report("enriching", pct);
+      }
+    }
+  }
+  const processed = processedSoFar();
+  const result = {
+    enriched,
+    patternsFound,
+    durationMs: Date.now() - startTime,
+    considered,
+    unchanged,
+    danglingSources,
+    unresolvedTargets,
+    danglingTargets,
+    rowsWithoutParseableMetadata,
+    failedPages,
+    failedRows,
+    firstError,
+    truncated,
+    // A floor, not an exact count: the source-side join drops `danglingSources`
+    // rows that this pass can never enrich, so the true unreached count is at
+    // most this number and is reported as an at-least.
+    skipped: truncated ? Math.max(0, totalRels - processed - danglingSources) : 0,
+    cap: maxRows,
+    pagination,
+    staleInScope
+  };
+  if (truncated) {
+    log.warn("relationship enrichment: work cap reached, pass is PARTIAL", {
+      projectId: String(projectId).slice(0, 8),
+      cap: maxRows,
+      processed,
+      totalRelationships: totalRels,
+      skipped: result.skipped
+    });
+  }
+  if (failedPages > 0) {
+    log.warn("relationship enrichment: PARTIAL \u2014 some pages failed and were left un-enriched", {
+      projectId: String(projectId).slice(0, 8),
+      failedPages,
+      failedRows,
+      firstError
+    });
+  }
+  if (rowsWithoutParseableMetadata > 0) {
+    log.warn("relationship enrichment: pre-existing metadata was unparseable and was replaced", {
+      projectId: String(projectId).slice(0, 8),
+      rows: rowsWithoutParseableMetadata
+    });
+  }
+  if (danglingTargets > 0) {
+    log.warn("relationship enrichment: dangling TARGET edges present (target_symbol_id names no symbol)", {
+      projectId: String(projectId).slice(0, 8),
+      danglingTargets
+    });
+  }
+  report(truncated ? "capped" : "done", 100);
+  return result;
+}
+function countStaleInScope(rawDb, projectId, scopeIds) {
+  const CHUNK = 500;
+  let total = 0;
+  for (let i = 0; i < scopeIds.length; i += CHUNK) {
+    const chunk = scopeIds.slice(i, i + CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    try {
+      const row = rawDb.prepare(`
+        SELECT COUNT(*) as c FROM brain_relationship r
+        WHERE r.project_id = ?
+          AND r.target_symbol_id IN (${placeholders})
+          AND r.metadata IS NOT NULL
+          AND json_valid(r.metadata)
+          AND json_extract(r.metadata, '$.inferredAt') IS NOT NULL
+          AND json_extract(r.metadata, '$.inferredAt') < r.time_updated
+      `).get(projectId, ...chunk);
+      total += row?.c ?? 0;
+    } catch (e) {
+      log.warn("relationship enrichment: stale-in-scope count unavailable", { error: e?.message });
+      return total;
+    }
+  }
+  return total;
+}
+function inferPattern(row) {
+  const rt = row.relationship_type;
+  const sn = (row.source_name || "").toLowerCase();
+  const tn = (row.target_name || "").toLowerCase();
+  const st = (row.source_type || "").toLowerCase();
+  const tt = (row.target_type || "").toLowerCase();
+  if (rt === "calls" && (tn.includes("factory") || tn.includes("builder") || tn.includes("create") || tn.includes("build") || tn.includes("new"))) {
+    return "factory_consumer";
+  }
+  if (rt === "calls" && /^(on|handle|listen|notify|emit|fire|addListener|removeListener|subscribe|unsubscribe)/i.test(tn)) {
+    return "observer";
+  }
+  if (rt === "calls" && (sn.includes("callback") || sn.includes("handler") || tn.endsWith("callback"))) {
+    return "callback";
+  }
+  if (rt === "calls" && (sn.includes("event") || tn.includes("event"))) {
+    return "event_handler";
+  }
+  if (rt === "implements" && (tt === "interface" || tt === "trait" || tt === "protocol")) {
+    return "adapter";
+  }
+  if ((sn.includes("adapter") || sn.includes("wrapper") || sn.includes("decorator")) && rt === "calls") {
+    return "adapter";
+  }
+  if (rt === "instantiates" && (tt === "interface" || tt === "trait" || tt === "abstract" || tt === "protocol")) {
+    return "di_injection";
+  }
+  if (rt === "overrides") {
+    return "override";
+  }
+  if (rt === "calls" && (sn.includes("delegate") || tn.includes("delegate") || tn.includes("proxy"))) {
+    return "delegate";
+  }
+  return null;
+}
+function inferRole(relationshipType, sourceType, targetType, pattern) {
+  const st = (sourceType || "").toLowerCase();
+  const tt = (targetType || "").toLowerCase();
+  if (relationshipType === "extends") return "inheritor";
+  if (relationshipType === "implements") return "implementor";
+  if (relationshipType === "overrides") return "inheritor";
+  if (relationshipType === "instantiates") {
+    if (tt === "interface" || tt === "trait" || tt === "protocol") return "configurator";
+    return "producer";
+  }
+  if (relationshipType === "calls") {
+    if (pattern === "observer" || pattern === "callback" || pattern === "event_handler") return "consumer";
+    if (pattern === "adapter") return "decorator";
+    if (pattern === "di_injection") return "configurator";
+    return "consumer";
+  }
+  if (relationshipType === "uses" || relationshipType === "references" || relationshipType === "imports") {
+    return "consumer";
+  }
+  return void 0;
+}
+function formatEnrichedRelationship(row) {
+  let meta = {};
+  try {
+    meta = row.rel_metadata ? JSON.parse(row.rel_metadata) : row.metadata ? JSON.parse(row.metadata) : {};
+  } catch {
+  }
+  if (meta === null || typeof meta !== "object" || Array.isArray(meta)) meta = {};
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : null;
+  const bool = (v) => v === true;
+  const parts = [];
+  const role = str(meta.role);
+  const pattern = str(meta.pattern);
+  if (role || pattern) {
+    const labels = [];
+    if (role) labels.push(role);
+    if (pattern) labels.push(pattern.replace(/_/g, " "));
+    parts.push(`[${labels.join(" \xB7 ")}]`);
+  }
+  const layerFlow = str(meta.layerFlow);
+  if (layerFlow && layerFlow !== "core\u2192core") {
+    parts.push(`(${layerFlow})`);
+  }
+  if (meta.criticality === "high") {
+    parts.push(`\u{1F534}`);
+  } else if (meta.criticality === "medium") {
+    parts.push(`\u{1F7E1}`);
+  }
+  const frequency = str(meta.frequency);
+  if (frequency && frequency !== "one_of_0") {
+    parts.push(`\xD7${frequency.replace("one_of_", "")}`);
+  }
+  const flags = [];
+  if (bool(meta.isTestCode)) flags.push("\u{1F9EA}");
+  if (bool(meta.isFrameworkContract)) flags.push("\u{1F4DC}");
+  if (bool(meta.isGeneratedCode)) flags.push("\u{1F916}");
+  if (bool(meta.isDependencyInjection)) flags.push("\u{1F489}");
+  if (flags.length > 0) parts.push(flags.join(""));
+  return parts.length > 0 ? parts.join(" ") : "";
+}
+function normalizeMaxResults(value) {
+  if (value === void 0 || value === null) return 100;
+  const n = Math.trunc(Number(value));
+  if (!Number.isFinite(n) || n < 0) return 100;
+  return n;
+}
+async function getEnrichedRelationships(projectId, options = {}) {
+  const rawDb = await BrainDatabase.getRawInstance(projectId);
+  const conditions = ["r.project_id = ?"];
+  const params = [projectId];
+  if (options.sourceSymbolId) {
+    conditions.push("r.source_symbol_id = ?");
+    params.push(options.sourceSymbolId);
+  }
+  if (options.targetSymbolId) {
+    conditions.push("r.target_symbol_id = ?");
+    params.push(options.targetSymbolId);
+  }
+  if (options.relationshipType) {
+    conditions.push("r.relationship_type = ?");
+    params.push(options.relationshipType);
+  }
+  const limit = normalizeMaxResults(options.maxResults);
+  const metadataColumn = options.includeEnrichment === false ? "NULL as metadata" : "r.metadata";
+  const where = conditions.join(" AND ");
+  return rawDb.prepare(`
+    SELECT r.id, r.relationship_type, ${metadataColumn},
+           s.name as source_name, s.symbol_type as source_type, s.layer as source_layer,
+           t.name as target_name, t.symbol_type as target_type, t.layer as target_layer,
+           sf.relative_path as source_file, sf.language as source_language,
+           tf.relative_path as target_file, tf.language as target_language,
+           r.is_cross_file, r.is_cross_language, r.bridge_mechanism
+    FROM brain_relationship r
+    JOIN brain_symbol s ON s.id = r.source_symbol_id AND s.project_id = r.project_id
+    JOIN brain_file sf ON sf.id = s.file_id
+    LEFT JOIN brain_symbol t ON t.id = r.target_symbol_id AND t.project_id = r.project_id
+    LEFT JOIN brain_file tf ON tf.id = t.file_id
+    WHERE ${where}
+    ORDER BY s.name, t.name
+    LIMIT ${limit}
+  `).all(...params);
+}
+export {
+  ENRICHMENT_MAX_ROWS,
+  enrichRelationships,
+  formatEnrichedRelationship,
+  getEnrichedRelationships
+};

package/dist/brain.sql-EIM4WS4D.js

@@ -0,0 +1,29 @@
+import {
+  BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable,
+  BrainAnalysisRunTable,
+  BrainFileTable,
+  BrainImportTable,
+  BrainIndexStatusTable,
+  BrainProjectHealthTable,
+  BrainQueryCacheTable,
+  BrainRelationshipTable,
+  BrainSemanticEmbeddingTable,
+  BrainSymbolTable,
+  BrainTaintFlowTable
+} from "./chunk-ROMM6KMC.js";
+import "./chunk-MLKGABMK.js";
+export {
+  BrainAnalysisFindingTable,
+  BrainAnalysisOccurrenceTable,
+  BrainAnalysisRunTable,
+  BrainFileTable,
+  BrainImportTable,
+  BrainIndexStatusTable,
+  BrainProjectHealthTable,
+  BrainQueryCacheTable,
+  BrainRelationshipTable,
+  BrainSemanticEmbeddingTable,
+  BrainSymbolTable,
+  BrainTaintFlowTable
+};