@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/cube-stats/fetcher.js

@@ -0,0 +1,194 @@
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+/** Server-side `}StatsByCube` measure labels mapped to stable typed fields. */
+export const KNOWN_METRICS = {
+    "Memory Used for Views": "memoryViews",
+    "Memory Used for Input Data": "memoryInput",
+    "Memory Used for Feeders": "memoryFeeders",
+    "Memory Used for Calculations": "memoryCalculations",
+    "Total Memory Used": "memoryTotal",
+    "Number of Populated Numeric Cells": "populatedNumeric",
+    "Number of Populated String Cells": "populatedString",
+    "Number of Stored Calculated Cells": "storedCalculated",
+    "Number of Stored Views": "storedViews",
+    "Number of Fed Cells": "fedCells",
+    "Steps of Average Calculation": "avgCalculationSteps",
+    "Rule calculation cache miss rate": "cacheMissRate",
+};
+/**
+ * Thrown by `fetchCubeStats` when `}StatsByCube` cannot be read for a reason
+ * that is a property of the *server or the account*, not of the cube being
+ * asked about. Callers should surface `message` verbatim and branch on
+ * `reason`; anything else that fails still propagates unchanged.
+ */
+export class CubeStatsUnavailableError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.name = "CubeStatsUnavailableError";
+        this.reason = reason;
+    }
+}
+/** The cube the MDX reads. Probed by name when the query fails. */
+export const STATS_CUBE = "}StatsByCube";
+/**
+ * The one string this module compares against, and it is not prose: TM1's
+ * object-level denial identifier. It is an error code — it appears verbatim
+ * in the payload on a German or Japanese server exactly as it does on an
+ * English one, which is precisely why it is safe to match and a sentence
+ * is not.
+ */
+const DENIAL_IDENTIFIER = "ObjectSecurityNoReadRights";
+/**
+ * Connection-scoped capability verdict, same idea as `BatchService.supported`:
+ * once the server has answered whether `}StatsByCube` exists, that is fixed
+ * for the connection, so an audit over 200 cubes neither fires 200 doomed MDX
+ * queries nor 200 existence probes. A denial is deliberately NOT cached — an
+ * administrator can grant rights mid-session, so it is re-probed every time.
+ */
+const statsCubeVerdict = new WeakMap();
+function isDenial(err) {
+    if (err instanceof TM1Error) {
+        if (err.code === TM1ErrorCode.PERMISSION_DENIED)
+            return true;
+        if ((err.details ?? "").includes(DENIAL_IDENTIFIER))
+            return true;
+    }
+    // Non-TM1Error wrappers: the identifier still travels in the text.
+    return err instanceof Error && err.message.includes(DENIAL_IDENTIFIER);
+}
+function deniedError() {
+    return new CubeStatsUnavailableError("denied", `Reading the ${STATS_CUBE} control cube was refused for the current TM1 user ` +
+        `(${DENIAL_IDENTIFIER}), so cube statistics are unavailable. The statistics cubes ` +
+        `are present on this server — this is a rights issue, not a missing feature. ` +
+        `Control-object read access is normally admin-only; ask an administrator for read ` +
+        `rights on ${STATS_CUBE}, or run this with an admin account.`);
+}
+function absentError(version) {
+    const versionNote = version === 12
+        ? "This server reports TM1 v12, which is the known case: Planning Analytics Engine " +
+            "ships no }Stats* performance control cubes (verified on 12.5.9)."
+        : "Known case: TM1 v12 / Planning Analytics Engine ships no }Stats* performance " +
+            "control cubes (verified on 12.5.9); TM1 v11 exposes them.";
+    return new CubeStatsUnavailableError("absent", `The ${STATS_CUBE} control cube does not exist on this server, so cube statistics ` +
+        `cannot be read. ${versionNote} Nothing is wrong with your model, and no account ` +
+        `can read these numbers here — use rule/feeder static analysis instead.`);
+}
+/**
+ * Map a `}StatsByCube` MDX failure onto an unavailability verdict, or `null`
+ * when the failure is about something else (a nonexistent target cube, a
+ * syntax error, a timeout, a 500) and must propagate untouched.
+ *
+ * Structural, in two steps, neither of which reads a sentence:
+ *
+ *  1. Denial by identifier. TM1 refuses a control-object read with HTTP 400
+ *     carrying `ObjectSecurityNoReadRights` (not 403), which `classifyHttpError`
+ *     already turns into `PERMISSION_DENIED`. Checked first, because "you may
+ *     not read it" must never be reported as "this server does not have it".
+ *  2. Existence, asked of the server: `GET /api/v1/Cubes('}StatsByCube')`.
+ *     404 → the cube is genuinely not there → `absent`. 200 → the cube is
+ *     there and the MDX failed for some other reason entirely → `null`, and
+ *     the original error propagates. One cheap request, only on the failure
+ *     path, answering the actual question instead of inferring it.
+ *
+ * The probe's own failure never masks the real error: if the probe cannot
+ * answer, the original error wins.
+ *
+ * `version` feeds the wording only; nothing branches on it.
+ */
+export async function classifyCubeStatsFailure(tm1Client, err) {
+    if (isDenial(err))
+        return deniedError();
+    const cached = statsCubeVerdict.get(tm1Client);
+    if (cached)
+        return cached === "present" ? null : cached;
+    let present;
+    try {
+        present = await tm1Client.cubes.exists(STATS_CUBE);
+    }
+    catch (probeErr) {
+        // Probing is itself a control-object read, so it can be refused where the
+        // MDX was refused for a different reason. Any other probe failure means
+        // we simply do not know — say nothing and let the original error stand.
+        return isDenial(probeErr) ? deniedError() : null;
+    }
+    if (present) {
+        statsCubeVerdict.set(tm1Client, "present");
+        return null;
+    }
+    const verdict = absentError(tm1Client.version);
+    statsCubeVerdict.set(tm1Client, verdict);
+    return verdict;
+}
+export async function fetchCubeStats(tm1Client, cubeName) {
+    const known = statsCubeVerdict.get(tm1Client);
+    if (known && known !== "present")
+        throw known;
+    const safe = cubeName.replace(/]/g, "]]");
+    const mdx = [
+        "SELECT",
+        `  {[}PerfCubes].[}PerfCubes].[${safe}]} ON 0,`,
+        "  {TM1FILTERBYLEVEL({TM1SUBSETALL([}StatsStatsByCube].[}StatsStatsByCube])}, 0)} ON 1",
+        "FROM [}StatsByCube]",
+        "WHERE ([}TimeIntervals].[LATEST])",
+    ].join("\n");
+    let result;
+    try {
+        result = await tm1Client.cells.executeMdx(mdx);
+    }
+    catch (err) {
+        const unavailable = await classifyCubeStatsFailure(tm1Client, err);
+        if (!unavailable)
+            throw err;
+        throw unavailable;
+    }
+    const raw = {};
+    const tuples = result.axes[1]?.tuples ?? [];
+    for (let i = 0; i < tuples.length; i++) {
+        const memberName = tuples[i].members[0]?.name ?? `unknown_${i}`;
+        const cell = result.cells[i];
+        raw[memberName] = typeof cell?.value === "number" ? cell.value : null;
+    }
+    const item = { cubeName, raw };
+    for (const [src, target] of Object.entries(KNOWN_METRICS)) {
+        const v = raw[src];
+        if (typeof v === "number")
+            item[target] = v;
+    }
+    // Derived metric: feederEfficiency = fedCells / populatedNumeric.
+    const fed = item.fedCells;
+    const populated = item.populatedNumeric;
+    if (typeof fed === "number" &&
+        typeof populated === "number" &&
+        populated > 0) {
+        item.feederEfficiency = Number((fed / populated).toFixed(3));
+    }
+    return item;
+}
+/**
+ * Fed-to-populated ratio: `fedCells / populatedNumeric` — the community-
+ * standard }StatsByCube overfeeding indicator (tm1forum t=13110, Cubewise).
+ * Rule of thumb: ≥ 50× suspicious, ≥ 100× definite overfeeding. Returns
+ * `null` when either input is missing or `populatedNumeric` is zero — a
+ * cube fed purely cross-cube can legitimately hold no input data, so a
+ * missing denominator is "insufficient signal", not overfeeding.
+ */
+export function computeFedToPopulatedRatio(stats) {
+    const pop = stats.populatedNumeric;
+    const fed = stats.fedCells;
+    if (typeof pop !== "number" || typeof fed !== "number" || pop <= 0)
+        return null;
+    return fed / pop;
+}
+/**
+ * Feeder-memory ratio: `memoryFeeders / memoryInput` — secondary overfeeding
+ * signal (feeder flags dwarfing the data they feed from). No community
+ * threshold established; reported as context only, never flagged.
+ */
+export function computeFeederMemoryRatio(stats) {
+    const feeders = stats.memoryFeeders;
+    const input = stats.memoryInput;
+    if (typeof feeders !== "number" || typeof input !== "number" || input <= 0)
+        return null;
+    return feeders / input;
+}
+//# sourceMappingURL=fetcher.js.map

package/dist/lib/feeders/brackets.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Bracket-list parser for TM1 rules / feeders.
+ *
+ * Handles both syntactic forms found in real cube rules:
+ *  - **Qualified**:  `['Dim':'Elem']`, `['Dim':{'E1','E2'}]`
+ *  - **Positional** (most common in feeders): `['Elem1','Elem2','Elem3']`
+ *  - **Mixed**:  `['Year':'2026', 'Sales']`
+ *
+ * Why a new parser instead of `parseBracketDimRefs` in rulesLinter.ts:
+ * the existing one only matches the `'Dim':'Elem'` regex form and silently
+ * skips bare positional element lists, which dominate real feeder code
+ * (probe on 2026-05-18 found 92 / 125 feeder lines miss the existing parser).
+ *
+ * String escaping follows TM1 SQL-style: a literal single quote is written
+ * as two consecutive single quotes (`'It''s'` → `It's`).
+ */
+export interface BracketEntry {
+    /** Set when the entry is qualified (`'Dim':...`). */
+    dim?: string;
+    /** Single-element value (positional or `'Dim':'Elem'`). */
+    elem?: string;
+    /** Multi-element set: `'Dim':{'E1','E2'}`. */
+    elems?: string[];
+}
+export interface BracketList {
+    entries: BracketEntry[];
+    /** True iff every entry is unqualified (`{ elem }` only). Empty bracket = true. */
+    isPositional: boolean;
+    /** True iff entries contain both qualified and positional forms. */
+    isMixed: boolean;
+    /** Byte offsets in the source line — useful for diagnostic messages. */
+    startIndex: number;
+    endIndex: number;
+}
+/**
+ * Parse the first complete `[...]` list found in `text`. Returns `null` if
+ * no opening bracket exists outside string literals or the bracket is
+ * malformed / unterminated.
+ */
+export declare function parseBracketList(text: string): BracketList | null;
+/**
+ * Scan `line` for every complete top-level `[...]` list and return them in
+ * source order. Brackets inside single-quoted string literals are ignored.
+ * Malformed lists are skipped silently — extraction is best-effort.
+ */
+export declare function extractBracketLists(line: string): BracketList[];
+//# sourceMappingURL=brackets.d.ts.map

package/dist/lib/feeders/brackets.js

@@ -0,0 +1,195 @@
+/**
+ * Bracket-list parser for TM1 rules / feeders.
+ *
+ * Handles both syntactic forms found in real cube rules:
+ *  - **Qualified**:  `['Dim':'Elem']`, `['Dim':{'E1','E2'}]`
+ *  - **Positional** (most common in feeders): `['Elem1','Elem2','Elem3']`
+ *  - **Mixed**:  `['Year':'2026', 'Sales']`
+ *
+ * Why a new parser instead of `parseBracketDimRefs` in rulesLinter.ts:
+ * the existing one only matches the `'Dim':'Elem'` regex form and silently
+ * skips bare positional element lists, which dominate real feeder code
+ * (probe on 2026-05-18 found 92 / 125 feeder lines miss the existing parser).
+ *
+ * String escaping follows TM1 SQL-style: a literal single quote is written
+ * as two consecutive single quotes (`'It''s'` → `It's`).
+ */
+function readQuotedString(src, i) {
+    if (src[i] !== "'")
+        return null;
+    let j = i + 1;
+    let out = "";
+    while (j < src.length) {
+        const c = src[j];
+        if (c === "'") {
+            if (src[j + 1] === "'") {
+                out += "'";
+                j += 2;
+                continue;
+            }
+            return { value: out, next: j + 1 };
+        }
+        out += c;
+        j++;
+    }
+    return null;
+}
+function skipWs(src, i) {
+    while (i < src.length && /\s/.test(src[i]))
+        i++;
+    return i;
+}
+function readSet(src, i) {
+    if (src[i] !== "{")
+        return null;
+    let j = i + 1;
+    const values = [];
+    while (j < src.length) {
+        j = skipWs(src, j);
+        if (src[j] === "}")
+            return { values, next: j + 1 };
+        const s = readQuotedString(src, j);
+        if (!s)
+            return null;
+        values.push(s.value);
+        j = skipWs(src, s.next);
+        if (src[j] === ",") {
+            j++;
+            continue;
+        }
+        if (src[j] === "}")
+            return { values, next: j + 1 };
+        return null;
+    }
+    return null;
+}
+function readEntry(src, i) {
+    const first = readQuotedString(src, i);
+    if (!first)
+        return null;
+    let j = skipWs(src, first.next);
+    if (src[j] === ":") {
+        j = skipWs(src, j + 1);
+        if (src[j] === "{") {
+            const set = readSet(src, j);
+            if (!set)
+                return null;
+            return { entry: { dim: first.value, elems: set.values }, next: set.next };
+        }
+        const rhs = readQuotedString(src, j);
+        if (!rhs)
+            return null;
+        return { entry: { dim: first.value, elem: rhs.value }, next: rhs.next };
+    }
+    return { entry: { elem: first.value }, next: first.next };
+}
+function parseBracketAt(src, start) {
+    if (src[start] !== "[")
+        return null;
+    const entries = [];
+    let j = skipWs(src, start + 1);
+    if (src[j] === "]") {
+        return {
+            list: {
+                entries,
+                isPositional: true,
+                isMixed: false,
+                startIndex: start,
+                endIndex: j,
+            },
+            next: j + 1,
+        };
+    }
+    while (j < src.length) {
+        const e = readEntry(src, j);
+        if (!e)
+            return null;
+        entries.push(e.entry);
+        j = skipWs(src, e.next);
+        if (src[j] === ",") {
+            j = skipWs(src, j + 1);
+            continue;
+        }
+        if (src[j] === "]") {
+            let qualifiedCount = 0;
+            let positionalCount = 0;
+            for (const en of entries) {
+                if (en.dim !== undefined)
+                    qualifiedCount++;
+                else
+                    positionalCount++;
+            }
+            const isPositional = qualifiedCount === 0;
+            const isMixed = qualifiedCount > 0 && positionalCount > 0;
+            return {
+                list: {
+                    entries,
+                    isPositional,
+                    isMixed,
+                    startIndex: start,
+                    endIndex: j,
+                },
+                next: j + 1,
+            };
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Parse the first complete `[...]` list found in `text`. Returns `null` if
+ * no opening bracket exists outside string literals or the bracket is
+ * malformed / unterminated.
+ */
+export function parseBracketList(text) {
+    let i = 0;
+    while (i < text.length) {
+        const c = text[i];
+        if (c === "'") {
+            const s = readQuotedString(text, i);
+            if (!s)
+                return null;
+            i = s.next;
+            continue;
+        }
+        if (c === "[") {
+            const r = parseBracketAt(text, i);
+            return r ? r.list : null;
+        }
+        i++;
+    }
+    return null;
+}
+/**
+ * Scan `line` for every complete top-level `[...]` list and return them in
+ * source order. Brackets inside single-quoted string literals are ignored.
+ * Malformed lists are skipped silently — extraction is best-effort.
+ */
+export function extractBracketLists(line) {
+    const out = [];
+    let i = 0;
+    while (i < line.length) {
+        const c = line[i];
+        if (c === "'") {
+            const s = readQuotedString(line, i);
+            if (!s)
+                break;
+            i = s.next;
+            continue;
+        }
+        if (c === "[") {
+            const r = parseBracketAt(line, i);
+            if (r) {
+                out.push(r.list);
+                i = r.next;
+            }
+            else {
+                i++;
+            }
+            continue;
+        }
+        i++;
+    }
+    return out;
+}
+//# sourceMappingURL=brackets.js.map

package/dist/lib/feeders/element-type-cache.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Element-type cache for feeder audit heuristics.
+ *
+ * Looks up `(dim, hierarchy, element) → "Numeric" | "Consolidated" | "String"`
+ * via the hierarchy service. One REST call per `(dim, hier)` pair; subsequent
+ * lookups hit the in-memory map.
+ *
+ * Failure handling is bounded-retry, not cache-the-failure: the first
+ * `MAX_CONSECUTIVE_LOAD_FAILURES - 1` failed loads leave the slot unset so a
+ * later lookup retries and a transient timeout can heal; once that many
+ * consecutive failures pile up the slot is pinned to `null` and no further
+ * requests are issued for it. Concurrent lookups share the single in-flight
+ * attempt, and a shared failing attempt counts as one failure — the budget is
+ * spent per attempt, not per waiting caller.
+ *
+ * The read goes through `getElementTypes` (`$select=Name,Type`), not the full
+ * `get()` — the latter drags `$expand=Parents` plus an Edges scan along for a
+ * lookup that only needs the type.
+ *
+ * TM1 element name comparison is case-insensitive; normalize on both store and
+ * lookup paths so positional/qualified mixing in feeders resolves correctly.
+ */
+import type { HierarchyElement } from "../../types.js";
+export type ElementType = "Numeric" | "Consolidated" | "String";
+interface HierarchyLike {
+    getElementTypes(dimensionName: string, hierarchyName: string): Promise<Array<{
+        name: string;
+        type: HierarchyElement["type"];
+    }>>;
+}
+export declare class ElementTypeCache {
+    private readonly hierarchy;
+    private readonly slots;
+    private readonly pending;
+    /** Consecutive failed loads per slot; cleared on success, see load(). */
+    private readonly failures;
+    constructor(hierarchy: HierarchyLike);
+    getType(dim: string, hier: string, elem: string): Promise<ElementType | null>;
+    private load;
+}
+export {};
+//# sourceMappingURL=element-type-cache.d.ts.map

package/dist/lib/feeders/element-type-cache.js

@@ -0,0 +1,86 @@
+const VALID_TYPES = new Set(["Numeric", "Consolidated", "String"]);
+/**
+ * Consecutive failed loads of one `(dim, hier)` slot before the cache stops
+ * asking and pins that slot to `null` for its remaining lifetime.
+ *
+ * Balances two failure modes. Too low (1 = cache the failure) and a single
+ * transient timeout marks every element of that dimension "type unknown" for
+ * the whole audit run. Too high (unbounded retry) and a *deterministic*
+ * failure — the common case, since TM1 reports a security denial as HTTP 400
+ * `ObjectSecurityNoReadRights`, which any non-admin auditing a model with one
+ * restricted dimension hits — costs one failing REST call per feeder entry,
+ * serially, each able to run to the request timeout.
+ *
+ * No TTL on purpose: this cache is built fresh per tool invocation, so wall
+ * clock buys nothing and would only drag `Date.now()` into the tests.
+ */
+const MAX_CONSECUTIVE_LOAD_FAILURES = 3;
+function normalize(s) {
+    return s.toLowerCase();
+}
+export class ElementTypeCache {
+    hierarchy;
+    slots = new Map();
+    pending = new Map();
+    /** Consecutive failed loads per slot; cleared on success, see load(). */
+    failures = new Map();
+    constructor(hierarchy) {
+        this.hierarchy = hierarchy;
+    }
+    async getType(dim, hier, elem) {
+        const slotKey = `${normalize(dim)}|${normalize(hier)}`;
+        let slot = this.slots.get(slotKey);
+        if (slot === undefined) {
+            slot = await this.load(slotKey, dim, hier);
+        }
+        if (slot === null)
+            return null;
+        return slot.get(normalize(elem)) ?? null;
+    }
+    async load(slotKey, dim, hier) {
+        const inflight = this.pending.get(slotKey);
+        if (inflight)
+            return inflight;
+        // Resolver is created and registered eagerly so the in-flight slot is
+        // populated before any await hands control back to other callers; the
+        // actual REST work runs inside the returned promise.
+        let resolve;
+        const p = new Promise((r) => {
+            resolve = r;
+        });
+        this.pending.set(slotKey, p);
+        void (async () => {
+            try {
+                const elements = await this.hierarchy.getElementTypes(dim, hier);
+                const m = new Map();
+                for (const e of elements) {
+                    if (VALID_TYPES.has(e.type)) {
+                        m.set(normalize(e.name), e.type);
+                    }
+                }
+                this.slots.set(slotKey, m);
+                this.failures.delete(slotKey);
+                resolve(m);
+            }
+            catch {
+                // One attempt = one failure, however many callers awaited it.
+                const failed = (this.failures.get(slotKey) ?? 0) + 1;
+                this.failures.set(slotKey, failed);
+                if (failed >= MAX_CONSECUTIVE_LOAD_FAILURES) {
+                    // Budget spent: pin the slot so a deterministically broken or
+                    // access-denied dimension costs a bounded number of REST calls
+                    // instead of one per feeder entry.
+                    this.slots.set(slotKey, null);
+                }
+                // Below the threshold the slot stays unset, so the *next* getType()
+                // issues a fresh attempt and a transient error can still heal.
+                resolve(null);
+            }
+            finally {
+                this.pending.delete(slotKey);
+            }
+        })();
+        return p;
+    }
+}
+//# sourceMappingURL=element-type-cache.js.map

package/dist/lib/feeders/static-heuristics.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Static (rule-text only) overfeeding heuristics.
+ *
+ * Each detector takes already-parsed bracket lists (LHS of a single feeder or
+ * rule line) and returns a verdict. The tool layer composes these into
+ * findings with severity = "hint" since no runtime evidence is observed.
+ *
+ * Heuristic IDs match docs/internal/feeders-audit-spec.md:
+ *   S1 — feeder_broader_than_rule       (needs cubeTotalDims)
+ *   S2 — feeder_to_consolidated         (needs element-type cache)
+ *   S3 — wildcard_bracket
+ *   S4 — db_feeder_without_skipcheck
+ *   S5 — orphan_feeder
+ */
+import type { BracketList } from "./brackets.js";
+import type { ElementTypeCache } from "./element-type-cache.js";
+/**
+ * Pull every concrete element name out of a bracket list into a flat set.
+ * Positional, qualified, and set-form entries all contribute their element
+ * value(s). Dimension qualifiers are NOT bagged — only the element side.
+ */
+export declare function collectElementBag(list: BracketList): Set<string>;
+/**
+ * S3 · Wildcard / unscoped bracket — bracket has no concrete element
+ * constraints. Either an empty bracket or every entry lacks both `elem` and
+ * `elems`. Such feeders fire across every dim member.
+ */
+export declare function detectWildcardBracket(list: BracketList): boolean;
+/**
+ * S1 · Feeder broader than rule — feeder LHS pins a small fraction of the
+ * cube's dimensions. Ratio-based to scale across cube widths: an absolute
+ * "2 dims unpinned" threshold flooded findings on 13-dim cubes where
+ * positional feeders idiomatically pin 7–8 dims (live test 2026-05-19:
+ * 114/116 ≈ 98 % noise). The ratio gate restores precision because TM1
+ * fills the unpinned dims with default members — only when the feeder
+ * leaves most of the cube unconstrained is it genuinely too broad.
+ *
+ * Flags when `pinned / cubeTotalDims < minPinnedRatio` (default 0.5).
+ *
+ * Returns false on:
+ *  - empty bracket (S4 territory)
+ *  - missing cube dim count (resolver failure → cubeTotalDims ≤ 0)
+ *  - feeder pinning more entries than cube has dims (malformed; skip)
+ */
+export declare function detectBroaderThanRule(feeder: BracketList, cubeTotalDims: number, minPinnedRatio?: number): boolean;
+/**
+ * Pair a feeder LHS with the rule LHS that shares the most element-bag
+ * elements. Returns the best-match rule (overlap ≥ 1) or null. Ties go to
+ * the first match for determinism. Used by S1 so we can compare feeder
+ * pinning against the rule it actually feeds rather than against the
+ * cube-width ratio fallback.
+ */
+export declare function findMatchingRule(feederLhs: BracketList, ruleLhsList: readonly BracketList[]): BracketList | null;
+/**
+ * S1 (rule-paired variant) · Feeder broader than its matched rule.
+ *
+ * Strict comparison: flag iff `feeder.pinned < matchedRule.pinned`. Equal
+ * pinning is the idiomatic 1:1 TM1 N: pattern (e.g. `[M:A] => [M:B]`
+ * feeding `[M:B] = N: [M:A] - ...;`) and must NOT be flagged — empirical
+ * audits showed ~92 % FP rate before pairing was introduced.
+ */
+export declare function detectBroaderThanMatchedRule(feeder: BracketList, matchedRule: BracketList): boolean;
+/**
+ * S2 · Feeder targets consolidated element.
+ *
+ * For each entry in the feeder LHS, resolve `(dim, hier, elem)` and look up
+ * the element type via the cache. Flag on the first consolidated element
+ * encountered. Resolution rules:
+ *  - positional entry at index `i` → `dim = hier = cubeDimNames[i]`
+ *  - qualified entry `'Dim':'Elem'` → `dim = hier = Dim`
+ *  - qualified entry `'Dim:Hier':'Elem'` → split on `:` (only for the dim slot)
+ *  - set entries `'Dim':{'A','B'}` → check each element of the set
+ *
+ * Returns the matching `{dim, elem}` or `null`. The tool layer turns a
+ * non-null result into a finding with severity `hint`.
+ */
+export declare function detectFeederToConsolidated(feeder: BracketList, cubeDimNames: readonly string[], cache: ElementTypeCache): Promise<{
+    dim: string;
+    elem: string;
+} | null>;
+/**
+ * S4 · `DB()` feeder without skipcheck on target. Cross-cube feeders fan out
+ * through the target cube's consolidations; without `skipcheck;` on the
+ * target's rules the engine evaluates every cell. Walk every `DB(...)` call
+ * on the feeder line, ask the lookup whether the target cube has skipcheck.
+ *
+ * Returns the first target-cube name that lacks skipcheck, or `null` on:
+ *  - no `DB()` call on the line
+ *  - dynamic cube name (not a string literal — can't resolve statically)
+ *  - lookup returns `null` (target outside scan scope — be conservative)
+ *  - lookup returns `true` (skipcheck present)
+ */
+export declare function detectDbFeederWithoutSkipcheck(line: string, hasSkipcheck: (cubeName: string) => boolean | null): string | null;
+/**
+ * S5 · Orphan feeder — the feeder LHS shares no element name with any rule
+ * LHS in the cube. Pure overhead: it flags cells that no rule populates.
+ * Element comparison is bag-equality on the element-side only (dim
+ * qualifiers ignored), so positional and qualified syntax intermix.
+ */
+export declare function detectOrphanFeeder(feeder: BracketList, ruleLhsList: ReadonlyArray<BracketList>): boolean;
+//# sourceMappingURL=static-heuristics.d.ts.map