@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/complexity/process-metrics.js

@@ -0,0 +1,278 @@
+/**
+ * Per-process complexity metrics derived from TI source + variables.
+ *
+ * Metrics are designed to surface real maintainability pain (deep branching,
+ * uneven distribution across tabs, missing comments) — not vanity counts like
+ * raw variable totals.
+ */
+import { parseTiCode } from "../callgraph/tiParser.js";
+import { isCommentedOutCode } from "./comment-classifier.js";
+const DEFAULT_WEIGHTS = {
+    loopBase: 2,
+    nestMult: 3,
+    ifBase: 1,
+    hotPenalty: 2,
+    commentDiscountMax: 0,
+};
+/**
+ * Merge caller overrides onto defaults, ignoring undefined values so an
+ * explicitly-undefined field (e.g. from an omitted Zod key) never clobbers a
+ * default with undefined.
+ */
+function resolveWeights(weights) {
+    const w = { ...DEFAULT_WEIGHTS };
+    if (weights) {
+        for (const k of Object.keys(DEFAULT_WEIGHTS)) {
+            const v = weights[k];
+            if (typeof v === "number")
+                w[k] = v;
+        }
+    }
+    return w;
+}
+/**
+ * Functions whose execution inside a loop is a recognised performance hot path
+ * in TI (cell writes, file I/O, nested process calls). Case-insensitive match.
+ */
+const HOT_OPS = new Set([
+    "cellputn",
+    "cellputs",
+    "asciioutput",
+    "textoutput",
+    "executeprocess",
+    "runprocess",
+    "odbcoutput",
+]);
+/**
+ * Count AND/OR connectors (`&`, `%`) in a TI condition, ignoring any that sit
+ * inside single-quoted string literals. Complexity = 1 + connector count, so a
+ * lone comparison scores 1 and each extra clause adds 1.
+ */
+function conditionComplexity(condition) {
+    let connectors = 0;
+    let inString = false;
+    for (let i = 0; i < condition.length; i++) {
+        const c = condition[i];
+        if (c === "'") {
+            // Doubled '' is an escaped quote inside a string — skip the pair.
+            if (inString && condition[i + 1] === "'") {
+                i++;
+                continue;
+            }
+            inString = !inString;
+            continue;
+        }
+        if (inString)
+            continue;
+        if (c === "&" || c === "%")
+            connectors++;
+    }
+    return 1 + connectors;
+}
+const TABS = ["prolog", "metadata", "data", "epilog"];
+// Bedrock-generated TI processes pack many statements onto one line (e.g.
+// `IF(x);y=1;ENDIF;`). The parser is line-oriented for some block keywords,
+// so we normalize by inserting a newline after every top-level `;` (outside
+// of strings and `#` line-comments) before parsing. Raw LOC counts use the
+// original source via classifyLines.
+function splitMultiStatementLines(src) {
+    let out = "";
+    let inString = false;
+    let inLineComment = false;
+    for (let i = 0; i < src.length; i++) {
+        const c = src[i];
+        if (inLineComment) {
+            out += c;
+            if (c === "\n")
+                inLineComment = false;
+            continue;
+        }
+        if (inString) {
+            out += c;
+            if (c === "'") {
+                if (src[i + 1] === "'") {
+                    out += "'";
+                    i++;
+                }
+                else {
+                    inString = false;
+                }
+            }
+            continue;
+        }
+        if (c === "'") {
+            inString = true;
+            out += c;
+            continue;
+        }
+        if (c === "#") {
+            inLineComment = true;
+            out += c;
+            continue;
+        }
+        if (c === ";") {
+            out += ";";
+            const next = src[i + 1];
+            if (next !== undefined && next !== "\n" && next !== "\r") {
+                out += "\n";
+            }
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+function classifyLines(src) {
+    let loc = 0;
+    let commentLines = 0;
+    let deadCodeLines = 0;
+    let blankLines = 0;
+    for (const raw of src.split(/\r?\n/)) {
+        const t = raw.trim();
+        if (t === "")
+            blankLines++;
+        else if (t.startsWith("#")) {
+            if (isCommentedOutCode(t))
+                deadCodeLines++;
+            else
+                commentLines++;
+        }
+        else
+            loc++;
+    }
+    return { loc, commentLines, deadCodeLines, blankLines };
+}
+function walk(stmts, depth, acc) {
+    for (const s of stmts) {
+        if (s.type === "if") {
+            const ifBlk = s;
+            acc.branches += 1 + ifBlk.elseIfClauses.length;
+            const nextDepth = depth + 1;
+            if (nextDepth > acc.maxNesting)
+                acc.maxNesting = nextDepth;
+            walk(ifBlk.thenBody, nextDepth, acc);
+            for (const c of ifBlk.elseIfClauses)
+                walk(c.body, nextDepth, acc);
+            walk(ifBlk.elseBody, nextDepth, acc);
+        }
+        else if (s.type === "while") {
+            const whBlk = s;
+            acc.branches += 1;
+            const nextDepth = depth + 1;
+            if (nextDepth > acc.maxNesting)
+                acc.maxNesting = nextDepth;
+            walk(whBlk.body, nextDepth, acc);
+        }
+    }
+}
+/**
+ * v2 cost accumulator. Tracks loop and if nesting separately as it descends:
+ * loop cost grows geometrically with enclosing loops, if cost grows with
+ * condition complexity and if-depth, hot ops are penalised by loop depth.
+ */
+function walkCost(stmts, loopDepth, ifDepth, w, acc) {
+    for (const s of stmts) {
+        if (s.type === "if") {
+            const ifBlk = s;
+            acc.ifCost +=
+                w.ifBase * conditionComplexity(ifBlk.condition) * (1 + ifDepth);
+            for (const c of ifBlk.elseIfClauses) {
+                acc.ifCost +=
+                    w.ifBase * conditionComplexity(c.condition) * (1 + ifDepth);
+            }
+            walkCost(ifBlk.thenBody, loopDepth, ifDepth + 1, w, acc);
+            for (const c of ifBlk.elseIfClauses)
+                walkCost(c.body, loopDepth, ifDepth + 1, w, acc);
+            walkCost(ifBlk.elseBody, loopDepth, ifDepth + 1, w, acc);
+        }
+        else if (s.type === "while") {
+            const whBlk = s;
+            acc.loopCost += w.loopBase * Math.pow(w.nestMult, loopDepth);
+            walkCost(whBlk.body, loopDepth + 1, ifDepth, w, acc);
+        }
+        else if (s.type === "functionCall") {
+            const fn = s;
+            if (loopDepth > 0 && HOT_OPS.has(fn.name.toLowerCase())) {
+                acc.hotInLoop += w.hotPenalty * loopDepth;
+            }
+        }
+    }
+}
+export function computeTabMetrics(src, weights) {
+    const w = resolveWeights(weights);
+    const counts = classifyLines(src);
+    const parseRes = parseTiCode(splitMultiStatementLines(src));
+    const acc = { branches: 0, maxNesting: 0 };
+    const cost = { loopCost: 0, ifCost: 0, hotInLoop: 0 };
+    let parseError = false;
+    if (parseRes.ok) {
+        walk(parseRes.ast, 0, acc);
+        walkCost(parseRes.ast, 0, 0, w, cost);
+    }
+    else {
+        parseError = true;
+    }
+    return {
+        loc: counts.loc,
+        commentLines: counts.commentLines,
+        deadCodeLines: counts.deadCodeLines,
+        blankLines: counts.blankLines,
+        branches: acc.branches,
+        maxNesting: acc.maxNesting,
+        loopCost: cost.loopCost,
+        ifCost: cost.ifCost,
+        hotInLoop: cost.hotInLoop,
+        parseError,
+    };
+}
+export function computeProcessMetrics(name, code, weights) {
+    const w = resolveWeights(weights);
+    const tabs = {};
+    for (const t of TABS)
+        tabs[t] = computeTabMetrics(code[t] ?? "", w);
+    let loc = 0;
+    let commentLines = 0;
+    let deadCodeLines = 0;
+    let branches = 0;
+    let maxNesting = 0;
+    let loopCost = 0;
+    let ifCost = 0;
+    let hotInLoop = 0;
+    for (const t of TABS) {
+        loc += tabs[t].loc;
+        commentLines += tabs[t].commentLines;
+        deadCodeLines += tabs[t].deadCodeLines;
+        branches += tabs[t].branches;
+        if (tabs[t].maxNesting > maxNesting)
+            maxNesting = tabs[t].maxNesting;
+        loopCost += tabs[t].loopCost;
+        ifCost += tabs[t].ifCost;
+        hotInLoop += tabs[t].hotInLoop;
+    }
+    const score = loc + 2 * branches + 3 * maxNesting;
+    const denom = loc + commentLines + deadCodeLines;
+    const commentRatio = denom === 0 ? 0 : commentLines / denom;
+    const deadCodeRatio = denom === 0 ? 0 : deadCodeLines / denom;
+    const rawV2 = loc + ifCost + loopCost + hotInLoop;
+    const discount = Math.min(Math.max(w.commentDiscountMax, 0), 1) * commentRatio;
+    const scoreV2 = rawV2 * (1 - discount);
+    return {
+        name,
+        tabs,
+        totals: {
+            loc,
+            commentLines,
+            deadCodeLines,
+            branches,
+            maxNesting,
+            score,
+            loopCost,
+            ifCost,
+            hotInLoop,
+            scoreV2,
+            commentRatio,
+            deadCodeRatio,
+        },
+    };
+}
+//# sourceMappingURL=process-metrics.js.map

package/dist/lib/complexity/rules-metrics.d.ts

@@ -0,0 +1,31 @@
+export interface RulesMetrics {
+    cube: string;
+    /** Non-blank, non-comment lines in the rules section. */
+    rulesLoc: number;
+    /** Non-blank, non-comment lines in the feeders section. */
+    feedersLoc: number;
+    /** Rule-area lines (start with `[`) in the rules section. */
+    ruleCount: number;
+    /** Rule-area lines (start with `[`) in the feeders section. */
+    feederCount: number;
+    /** `#` lines that are real comments (prose), not disabled code. */
+    commentLines: number;
+    /** `#` lines that look like commented-out TM1 code (disabled statements). */
+    deadCodeLines: number;
+    /** commentLines / max(rulesLoc + feedersLoc + commentLines + deadCodeLines, 1). 0..1. */
+    commentRatio: number;
+    /** deadCodeLines / max(rulesLoc + feedersLoc + commentLines + deadCodeLines, 1). 0..1. */
+    deadCodeRatio: number;
+    /** `skipcheck;` directive present in the rules section. */
+    hasSkipcheck: boolean;
+    /** `feedstrings;` directive present in the rules section. */
+    hasFeedstrings: boolean;
+    /** Total DB(...) calls across all rule/feeder lines (string-literal aware). */
+    dbCallCount: number;
+    /** Distinct target cubes from DB('CubeName', ...) calls (string literals only). */
+    coupledCubes: string[];
+    /** Heuristic: rulesLoc + 2*ruleCount + 3*dbCallCount + 5*coupledCubes.length. */
+    score: number;
+}
+export declare function computeRulesMetrics(cube: string, rulesText: string): RulesMetrics;
+//# sourceMappingURL=rules-metrics.d.ts.map

package/dist/lib/complexity/rules-metrics.js

@@ -0,0 +1,99 @@
+/**
+ * Per-cube rules complexity metrics (regex/line-based MVP).
+ *
+ * Reuses parseRules (line classification + section tracking) and extractDbCalls
+ * (string/comment-aware DB() extraction). A future AST upgrade can replace the
+ * rule-line heuristic without changing this file's contract.
+ */
+import { parseRules } from "../callgraph/rulesParser.js";
+import { extractDbCalls } from "../callgraph/rulesLinter.js";
+import { isCommentedOutCode } from "./comment-classifier.js";
+const RULE_LINE_RE = /^\[/;
+function stripQuotes(s) {
+    // Strip matching pair only — leave mismatched quotes alone so we don't
+    // mangle an already-broken extracted argument (`'Foo"` stays `'Foo"`).
+    return s.replace(/^(['"])(.*)\1$/, "$2");
+}
+export function computeRulesMetrics(cube, rulesText) {
+    if (!rulesText || rulesText.trim() === "") {
+        return {
+            cube,
+            rulesLoc: 0,
+            feedersLoc: 0,
+            ruleCount: 0,
+            feederCount: 0,
+            commentLines: 0,
+            deadCodeLines: 0,
+            commentRatio: 0,
+            deadCodeRatio: 0,
+            hasSkipcheck: false,
+            hasFeedstrings: false,
+            dbCallCount: 0,
+            coupledCubes: [],
+            score: 0,
+        };
+    }
+    const ast = parseRules(rulesText);
+    let rulesLoc = 0;
+    let feedersLoc = 0;
+    let ruleCount = 0;
+    let feederCount = 0;
+    let commentLines = 0;
+    let deadCodeLines = 0;
+    let dbCallCount = 0;
+    const coupled = new Set();
+    for (const line of ast.lines) {
+        if (line.isBlank)
+            continue;
+        if (line.isComment) {
+            if (isCommentedOutCode(line.trimmed))
+                deadCodeLines++;
+            else
+                commentLines++;
+            continue;
+        }
+        // Section markers (`feeders;`) are dividers, not code — skip from LOC.
+        if (line.isFeedersMarker)
+            continue;
+        if (line.section === "rules") {
+            rulesLoc++;
+            if (RULE_LINE_RE.test(line.trimmed))
+                ruleCount++;
+        }
+        else {
+            feedersLoc++;
+            if (RULE_LINE_RE.test(line.trimmed))
+                feederCount++;
+        }
+        for (const call of extractDbCalls(line.trimmed)) {
+            dbCallCount++;
+            if (call.cubeName) {
+                const c = stripQuotes(call.cubeName);
+                if (c !== "")
+                    coupled.add(c);
+            }
+        }
+    }
+    const denom = rulesLoc + feedersLoc + commentLines + deadCodeLines;
+    const commentRatio = denom === 0 ? 0 : commentLines / denom;
+    const deadCodeRatio = denom === 0 ? 0 : deadCodeLines / denom;
+    const coupledCubes = [...coupled].sort();
+    const score = rulesLoc + 2 * ruleCount + 3 * dbCallCount + 5 * coupledCubes.length;
+    return {
+        cube,
+        rulesLoc,
+        feedersLoc,
+        ruleCount,
+        feederCount,
+        commentLines,
+        deadCodeLines,
+        commentRatio,
+        deadCodeRatio,
+        hasSkipcheck: ast.hasSkipcheck,
+        hasFeedstrings: ast.hasFeedstrings,
+        dbCallCount,
+        coupledCubes,
+        score,
+    };
+}
+//# sourceMappingURL=rules-metrics.js.map

package/dist/lib/concurrency.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Map over `items` running at most `limit` async calls in flight at once.
+ *
+ * Semantics mirror `Promise.allSettled` — the returned array is index-aligned
+ * with `items`, never rejects, and preserves per-item fulfilled/rejected status.
+ * The bound matters when fanning out one request per cube/process against TM1:
+ * an unbounded `Promise.allSettled` over a large model can flood the server's
+ * worker pool, whereas this keeps pressure constant.
+ */
+export declare function mapSettledWithConcurrency<T, R>(items: readonly T[], limit: number, fn: (item: T, index: number) => Promise<R>): Promise<PromiseSettledResult<R>[]>;
+//# sourceMappingURL=concurrency.d.ts.map

package/dist/lib/concurrency.js

@@ -0,0 +1,27 @@
+/**
+ * Map over `items` running at most `limit` async calls in flight at once.
+ *
+ * Semantics mirror `Promise.allSettled` — the returned array is index-aligned
+ * with `items`, never rejects, and preserves per-item fulfilled/rejected status.
+ * The bound matters when fanning out one request per cube/process against TM1:
+ * an unbounded `Promise.allSettled` over a large model can flood the server's
+ * worker pool, whereas this keeps pressure constant.
+ */
+export async function mapSettledWithConcurrency(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    const width = Math.max(1, Math.min(limit, items.length));
+    const workers = Array.from({ length: width }, async () => {
+        for (let i = next++; i < items.length; i = next++) {
+            try {
+                results[i] = { status: "fulfilled", value: await fn(items[i], i) };
+            }
+            catch (reason) {
+                results[i] = { status: "rejected", reason };
+            }
+        }
+    });
+    await Promise.all(workers);
+    return results;
+}
+//# sourceMappingURL=concurrency.js.map

package/dist/lib/control-name.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Shared predicate for TM1 control objects.
+ *
+ * IBM Planning Analytics names every server-internal object with a `}` prefix
+ * (e.g., `}ClientProperties`, `}tp_*`). All audit/listing tools filter these
+ * out by default, so the rule lives here instead of being re-implemented
+ * per tool.
+ */
+export declare const isControlName: (name: string) => boolean;
+//# sourceMappingURL=control-name.d.ts.map

package/dist/lib/control-name.js

@@ -0,0 +1,10 @@
+/**
+ * Shared predicate for TM1 control objects.
+ *
+ * IBM Planning Analytics names every server-internal object with a `}` prefix
+ * (e.g., `}ClientProperties`, `}tp_*`). All audit/listing tools filter these
+ * out by default, so the rule lives here instead of being re-implemented
+ * per tool.
+ */
+export const isControlName = (name) => name.startsWith("}");
+//# sourceMappingURL=control-name.js.map

package/dist/lib/coordinate-error.d.ts

@@ -0,0 +1,3 @@
+import { TM1Error } from "../types.js";
+export declare function dimensionCountMismatch(cubeName: string, dimensions: readonly string[], elements: readonly string[]): TM1Error;
+//# sourceMappingURL=coordinate-error.d.ts.map

package/dist/lib/coordinate-error.js

@@ -0,0 +1,29 @@
+// One error for "this coordinate has the wrong number of elements", shared by
+// every tool that addresses a cell positionally (get_cell_value, write_cells,
+// check_writable_coords).
+//
+// The bare count ("4 given, 5 expected") was the least useful part of the old
+// messages: the caller already knows it passed four. What it lacks is WHICH
+// dimension it forgot — typically one it does not think of as part of the cube,
+// such as a `Sandboxes` or `Version` dimension. So the message spells out the
+// cube's dimension order, names the uncovered positions, and `details` pairs
+// every dimension with the element that landed on it.
+import { TM1Error, TM1ErrorCode } from "../types.js";
+export function dimensionCountMismatch(cubeName, dimensions, elements) {
+    const missing = dimensions.slice(elements.length);
+    const extra = elements.slice(dimensions.length);
+    const gap = missing.length > 0
+        ? ` No element for ${missing.length === 1 ? "dimension" : "dimensions"} (by position): ${missing.join(", ")}.`
+        : ` ${extra.length} element(s) too many: ${extra.join(", ")}.`;
+    return new TM1Error({
+        code: TM1ErrorCode.VALIDATION_ERROR,
+        message: `Cube '${cubeName}' has ${dimensions.length} dimensions but ${elements.length} element(s) were given.` +
+            gap,
+        hint: `Pass exactly one element per dimension, in this order: ${dimensions.join(", ")}. A forgotten dimension anywhere in the list shifts every later element onto the wrong one — check the pairing in details.`,
+        details: JSON.stringify(dimensions.map((dimension, i) => ({
+            dimension,
+            element: elements[i] ?? null,
+        }))),
+    });
+}
+//# sourceMappingURL=coordinate-error.js.map

package/dist/lib/credential-format.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Whether exporting a datasource password to a file is worth offering at all,
+ * which turns on what the REST API actually hands out. Measured 2026-08-17
+ * against 11.8.02900.8 and a v12 database:
+ *
+ * - v11 returns a ciphertext bound to one *run* of one server. Within a running
+ *   instance it is stable — the same cleartext yields the same value across
+ *   processes — but it is useless on another instance, and equally useless on
+ *   the same instance after a service restart: the same password produced three
+ *   different values across two restarts, and a value carried across one aborts
+ *   the process at connect time with "Unable to open data source". Nothing
+ *   fixes that from our side, because the durable form (slot 565 of TM1's own
+ *   Datadir .pro, a longer encoding that is not even deterministic within a run)
+ *   is never exposed over REST.
+ * - v12 returns the plain password, which has no such lifetime.
+ *
+ * So a v11 export can only carry a credential through a window in which
+ * tm1_copy_process would have worked anyway, and fails silently outside it —
+ * the file still looks complete. Export therefore refuses on v11 and points at
+ * tm1_copy_process (to clone now) or dataSourcePassword (to deploy later).
+ */
+export declare function supportsCredentialExport(version: 11 | 12): boolean;
+//# sourceMappingURL=credential-format.d.ts.map

package/dist/lib/credential-format.js

@@ -0,0 +1,25 @@
+/**
+ * Whether exporting a datasource password to a file is worth offering at all,
+ * which turns on what the REST API actually hands out. Measured 2026-08-17
+ * against 11.8.02900.8 and a v12 database:
+ *
+ * - v11 returns a ciphertext bound to one *run* of one server. Within a running
+ *   instance it is stable — the same cleartext yields the same value across
+ *   processes — but it is useless on another instance, and equally useless on
+ *   the same instance after a service restart: the same password produced three
+ *   different values across two restarts, and a value carried across one aborts
+ *   the process at connect time with "Unable to open data source". Nothing
+ *   fixes that from our side, because the durable form (slot 565 of TM1's own
+ *   Datadir .pro, a longer encoding that is not even deterministic within a run)
+ *   is never exposed over REST.
+ * - v12 returns the plain password, which has no such lifetime.
+ *
+ * So a v11 export can only carry a credential through a window in which
+ * tm1_copy_process would have worked anyway, and fails silently outside it —
+ * the file still looks complete. Export therefore refuses on v11 and points at
+ * tm1_copy_process (to clone now) or dataSourcePassword (to deploy later).
+ */
+export function supportsCredentialExport(version) {
+    return version === 12;
+}
+//# sourceMappingURL=credential-format.js.map

package/dist/lib/cube-stats/fetcher.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Shared `}StatsByCube` fetcher.
+ *
+ * Reads one cube's perf metrics into a flat `{ measureName: value }` map
+ * plus a typed projection over well-known measures. Used by both
+ * `tm1_get_cube_stats` (read-tool) and `tm1_audit_feeders` (runtime mode).
+ *
+ * The MDX targets `}StatsByCube` (TM1 v11.8 layout verified live):
+ *   cube dim    → `}PerfCubes`
+ *   measure dim → `}StatsStatsByCube`
+ *   time dim    → `}TimeIntervals` sliced on `LATEST` for the current snapshot
+ * `TM1FILTERBYLEVEL` keeps only leaf measures.
+ *
+ * Not every server has those cubes. TM1 v12 / Planning Analytics Engine
+ * (measured on 12.5.9) ships control cubes for security and element
+ * attributes only — zero `}Stats*` — and a v11 non-admin can be refused read
+ * access to them. Both surfaced as raw OData text, which reads like the
+ * user's model is broken. `fetchCubeStats` classifies those two cases into a
+ * `CubeStatsUnavailableError` here, once, so every caller degrades the same
+ * way instead of re-deriving it at the tool layer.
+ *
+ * The classification is STRUCTURAL — it never reads the error sentence.
+ * Measured, same question asked three ways:
+ *   v11 11.8 (en) : '}StatsByCube' can not be found in collection of type 'Cube'
+ *   v12 12.5.9    : There is no cube named "}StatsByCube".
+ *   v11 11.8 (de) : Syntaxfehler bei oder in der Nähe von: '[…]', Zeichenposition 67
+ * The prose varies by version AND by server locale, so a matcher built on it
+ * is correct only on the machine it was written against and fails silently
+ * everywhere else — in the direction of showing the user a raw OData error.
+ * Instead: the denial is recognised by its untranslated identifier
+ * (`ObjectSecurityNoReadRights`, an error code), and absence is answered by
+ * asking the server directly whether the cube exists.
+ */
+import type { TM1Client } from "../../tm1-client.js";
+/** Server-side `}StatsByCube` measure labels mapped to stable typed fields. */
+export declare const KNOWN_METRICS: Record<string, string>;
+export interface CubeStatsItem {
+    cubeName: string;
+    raw: Record<string, number | null>;
+    error?: string;
+    feederEfficiency?: number;
+    [k: string]: unknown;
+}
+/**
+ * Why cube statistics could not be read — a distinction worth keeping honest:
+ *
+ * - `absent` — this server has no `}StatsByCube`. Nothing the caller can do;
+ *   no account has these numbers here.
+ * - `denied` — the cube exists, this TM1 user may not read it. A different
+ *   person, or the same person with control-object read rights, would get
+ *   the statistics. Telling them "your server does not have this" would be
+ *   a lie.
+ */
+export type StatsUnavailableReason = "absent" | "denied";
+/**
+ * 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 declare class CubeStatsUnavailableError extends Error {
+    readonly reason: StatsUnavailableReason;
+    constructor(reason: StatsUnavailableReason, message: string);
+}
+/** The cube the MDX reads. Probed by name when the query fails. */
+export declare const STATS_CUBE = "}StatsByCube";
+/**
+ * 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 declare function classifyCubeStatsFailure(tm1Client: TM1Client, err: unknown): Promise<CubeStatsUnavailableError | null>;
+export declare function fetchCubeStats(tm1Client: TM1Client, cubeName: string): Promise<CubeStatsItem>;
+/**
+ * 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 declare function computeFedToPopulatedRatio(stats: CubeStatsItem): number | null;
+/**
+ * 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 declare function computeFeederMemoryRatio(stats: CubeStatsItem): number | null;
+//# sourceMappingURL=fetcher.d.ts.map