@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/callgraph/tm1-adapter.d.ts

@@ -0,0 +1,32 @@
+import type { TM1Client } from "../../tm1-client.js";
+import { type ReferenceIndex } from "./referenceIndex.js";
+/**
+ * Wire the callgraph reference-index cache to tm1Events "mutation" notifications:
+ * any successful mutating HTTP call clears the cache so the next callgraph read
+ * rebuilds from fresh server state. The HTTP layer stays decoupled — it only
+ * emits the event; it holds no direct import of callgraph internals.
+ *
+ * Idempotent: safe to call once per TM1Client construction (or repeatedly)
+ * without stacking duplicate listeners on the process-global emitter.
+ */
+export declare function registerCallgraphCacheInvalidation(): void;
+export interface BuildIndexOpts {
+    includeControl?: boolean;
+    /** Force a fresh fetch and ignore cache. */
+    bypassCache?: boolean;
+}
+export declare function invalidateCallgraphCache(): {
+    cleared: number;
+};
+export declare function getCallgraphCacheStats(): Array<{
+    key: string;
+    ageMs: number;
+    ttlRemainingMs: number;
+    buildMs: number;
+}>;
+/**
+ * Build a full ReferenceIndex from a connected TM1 server.
+ * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ */
+export declare function buildIndexFromTM1(tm1Client: TM1Client, opts?: BuildIndexOpts): Promise<ReferenceIndex>;
+//# sourceMappingURL=tm1-adapter.d.ts.map

package/dist/lib/callgraph/tm1-adapter.js

@@ -0,0 +1,159 @@
+import { buildReferenceIndex, } from "./referenceIndex.js";
+import { tm1Events } from "../tm1-events.js";
+import { rethrowIfSystemic } from "../../tm1-client/services/fallback.js";
+// Cache-invalidation listener. Wired EXPLICITLY via
+// registerCallgraphCacheInvalidation() at client construction — no import-time
+// side-effect. Keeping this a named, stable function reference lets the wiring
+// be idempotent (the registrar checks for it before re-adding).
+// Data-plane paths that can never change the reference graph. The index is
+// built from process definitions, chore definitions and cube rules; none of
+// these endpoints touches any of that.
+//
+// This matters more than it looks: `ExecuteMDX` is a POST, so the HTTP layer
+// classifies every ordinary MDX *read* as a mutation. Before this filter a
+// single tm1_execute_mdx call threw away the whole callgraph index and forced
+// a full rebuild on the next analysis call.
+//
+// Deliberately an allowlist of known-inert paths, not a denylist of
+// code-relevant ones: anything unrecognised keeps invalidating, so a new
+// mutating endpoint is stale-safe by default.
+const INERT_PATHS = [/\/ExecuteMDX/i, /\/Cellsets/i, /tm1\.Update/i];
+function affectsReferenceGraph(path) {
+    return !INERT_PATHS.some((re) => re.test(path));
+}
+const invalidateOnMutation = (e) => {
+    if (!affectsReferenceGraph(e.path))
+        return;
+    invalidateCallgraphCache();
+};
+/**
+ * Wire the callgraph reference-index cache to tm1Events "mutation" notifications:
+ * any successful mutating HTTP call clears the cache so the next callgraph read
+ * rebuilds from fresh server state. The HTTP layer stays decoupled — it only
+ * emits the event; it holds no direct import of callgraph internals.
+ *
+ * Idempotent: safe to call once per TM1Client construction (or repeatedly)
+ * without stacking duplicate listeners on the process-global emitter.
+ */
+export function registerCallgraphCacheInvalidation() {
+    if (tm1Events.listeners("mutation").includes(invalidateOnMutation))
+        return;
+    tm1Events.on("mutation", invalidateOnMutation);
+}
+const CACHE_TTL_MS = 60_000;
+const cache = new Map();
+const inflight = new Map();
+// Monotonic counter bumped on every invalidation. Clearing `cache` alone is not
+// enough: a build that was already in flight when the mutation landed would
+// finish afterwards and write its PRE-mutation snapshot back with a FRESH
+// timestamp, republishing stale data for a full TTL. The build captures the
+// generation it started in and refuses to publish if that generation is gone.
+//
+// The in-flight caller still receives the index it asked for — it requested a
+// read that started before the mutation, so that result is merely old, not
+// wrong. What must not happen is that snapshot becoming the answer for everyone
+// else for the next 60 seconds.
+let generation = 0;
+export function invalidateCallgraphCache() {
+    const n = cache.size;
+    cache.clear();
+    generation++;
+    return { cleared: n };
+}
+export function getCallgraphCacheStats() {
+    const now = Date.now();
+    return Array.from(cache.entries()).map(([key, e]) => ({
+        key,
+        ageMs: now - e.ts,
+        ttlRemainingMs: Math.max(0, CACHE_TTL_MS - (now - e.ts)),
+        buildMs: e.buildMs,
+    }));
+}
+/**
+ * Build a full ReferenceIndex from a connected TM1 server.
+ * TTL-cached (60 s) per `includeControl` flag. Concurrent calls share one inflight promise.
+ */
+export async function buildIndexFromTM1(tm1Client, opts = {}) {
+    const includeControl = opts.includeControl ?? false;
+    const key = `inc=${includeControl}`;
+    if (!opts.bypassCache) {
+        const hit = cache.get(key);
+        if (hit && Date.now() - hit.ts < CACHE_TTL_MS)
+            return hit.index;
+        const pending = inflight.get(key);
+        if (pending)
+            return pending;
+    }
+    const promise = (async () => {
+        const start = Date.now();
+        const startGeneration = generation;
+        const idx = await buildIndexInternal(tm1Client, includeControl);
+        // Only publish if no invalidation happened while we were building.
+        if (generation === startGeneration) {
+            cache.set(key, {
+                index: idx,
+                ts: Date.now(),
+                buildMs: Date.now() - start,
+            });
+        }
+        return idx;
+    })();
+    inflight.set(key, promise);
+    try {
+        return await promise;
+    }
+    finally {
+        inflight.delete(key);
+    }
+}
+async function buildIndexInternal(tm1Client, includeControl) {
+    const fetchProcesses = async () => {
+        const all = await tm1Client.processes.fetchForCallgraph(includeControl);
+        return all.map((p) => ({
+            name: p.name,
+            prolog: p.prolog,
+            metadata: p.metadata,
+            data: p.data,
+            epilog: p.epilog,
+            parameters: p.parameters,
+            parameterDefaults: p.parameterDefaults,
+        }));
+    };
+    const fetchCubesWithRules = async () => {
+        const all = await tm1Client.cubes.getAllRules(includeControl);
+        return all.map((c) => ({ cubeName: c.cubeName, rulesText: c.rulesText }));
+    };
+    const fetchChores = async () => {
+        try {
+            const chs = await tm1Client.chores.list();
+            return chs
+                .filter((c) => includeControl || !c.name.startsWith("}"))
+                .map((c) => {
+                const tasks = c.processes.map((t, i) => ({
+                    step: i,
+                    processName: t.name,
+                    params: Object.entries(t.parameters).map(([name, val]) => ({
+                        name,
+                        value: String(val),
+                        type: typeof val === "number" ? "numeric" : "string",
+                    })),
+                }));
+                return { name: c.name, tasks };
+            });
+        }
+        catch (e) {
+            // Don't let an auth/connection/lock failure masquerade as "no chores" —
+            // that silently drops chore→process edges from the callgraph and the
+            // result looks complete. Real outages must propagate so the index is
+            // not built (and cached) from partial data.
+            rethrowIfSystemic(e);
+            return [];
+        }
+    };
+    return buildReferenceIndex({
+        fetchProcesses,
+        fetchCubesWithRules,
+        fetchChores,
+    });
+}
+//# sourceMappingURL=tm1-adapter.js.map

package/dist/lib/callgraph/types.d.ts

@@ -0,0 +1,53 @@
+/** Ergebnis des Parsers */
+export type TiParseResult = {
+    ok: true;
+    ast: TiAst;
+} | {
+    ok: false;
+    error: TiParseError;
+};
+export interface TiParseError {
+    line: number;
+    message: string;
+}
+/** AST = Array von Statements */
+export type TiAst = TiStatement[];
+export type TiStatement = TiAssignment | TiIfBlock | TiWhileBlock | TiFunctionCall;
+export interface TiAssignment {
+    type: "assignment";
+    variable: string;
+    expression: string;
+    /** true if the expression contains CellGetN/CellGetS */
+    isExternal: boolean;
+    /** Falls isExternal: Funktionsname und Parameter */
+    cellGetInfo?: {
+        fn: "CellGetN" | "CellGetS";
+        params: string[];
+    } | undefined;
+    line: number;
+}
+export interface TiIfBlock {
+    type: "if";
+    condition: string;
+    thenBody: TiStatement[];
+    elseIfClauses: Array<{
+        condition: string;
+        body: TiStatement[];
+        line: number;
+    }>;
+    elseBody: TiStatement[];
+    line: number;
+}
+export interface TiWhileBlock {
+    type: "while";
+    condition: string;
+    body: TiStatement[];
+    line: number;
+}
+export interface TiFunctionCall {
+    type: "functionCall";
+    name: string;
+    args: string[];
+    line: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/callgraph/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/callgraph/variableEnv.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Per-process variable environment.
+ *
+ * Classifies each assignment `var = expression;` as
+ *   - literal    (string literal or numeric literal)
+ *   - param      (reference to a process parameter, directly or via another local variable that is a param)
+ *   - datasource (reference to a DataSource variable whose value comes from the source data at runtime)
+ *   - dynamic    (everything else — CellGet, concatenation, function calls, IF, loops)
+ *
+ * Multi-assignment (a variable is assigned different values) → dynamic,
+ * because the value is no longer unambiguous at any given call site.
+ */
+export type TiVarType = "Numeric" | "String";
+export type VarBinding = {
+    kind: "literal";
+    value: string;
+} | {
+    kind: "param";
+    paramName: string;
+    paramType?: TiVarType | undefined;
+} | {
+    kind: "datasource";
+    varName: string;
+    varType: TiVarType;
+} | {
+    kind: "dynamic";
+};
+export interface ProcessEnv {
+    /** Parameter names of this process (lowercase). */
+    paramsLc: Set<string>;
+    /** Original-cased param names (for display). Map from lowercase → original. */
+    paramOriginal: Map<string, string>;
+    /** Parameter types (lowercase name → type). */
+    paramTypes: Map<string, TiVarType>;
+    /** DataSource variable names (lowercase → type + original casing). */
+    datasourceVars: Map<string, {
+        name: string;
+        type: TiVarType;
+    }>;
+    /** Local variable bindings (varname lowercase → resolved binding). */
+    vars: Map<string, VarBinding>;
+}
+/**
+ * Classify a single right-hand-side expression (no surrounding whitespace).
+ * Only handles simple cases:
+ *   'literal', 42, varName (→ lookup), paramName (→ param-ref), dsVarName (→ datasource-ref).
+ * Constant string-concatenation (all operands resolve to literals) folds to a literal.
+ * Everything else (function calls, concatenation with any non-literal operand, arithmetic, IF, brackets) → dynamic.
+ */
+export declare function resolveExpression(expr: string, env: ProcessEnv): VarBinding;
+export interface BuildEnvOptions {
+    /** 0-basierte, exklusive Zeilen-Obergrenze — Env wird nur aus Zeilen `< stopAtLine` gebaut. */
+    stopAtLine?: number;
+    /** Typ-Informationen pro Parameter (Key: lowercase Name). */
+    paramTypes?: Map<string, TiVarType>;
+    /** DataSource-Variablen-Definitionen (kommen aus dem Process-Objekt). */
+    datasourceVars?: Array<{
+        name: string;
+        type: TiVarType;
+    }>;
+    /**
+     * true: Mehrfach-Zuweisungen überschreiben (letzte Zuweisung gewinnt) — für Hover/Resolver-View,
+     * wo der User den aktuellen Stand an einer bestimmten Zeile sehen will.
+     * false (Default): Mehrfach-Zuweisungen mit unterschiedlichen Bindungen werden zu `dynamic` demoted —
+     * konservative Variante für Cross-Process-Referenztracking.
+     */
+    lastAssignmentWins?: boolean;
+    /**
+     * true: Flow-sensitive Auswertung (IF/ELSEIF/ELSE-Blöcke strukturell behandeln; siehe `flowSensitiveEnv.ts`).
+     * Nur sinnvoll in Kombination mit `lastAssignmentWins:true`. Bei Parse-Fehlern wird transparent
+     * auf den flow-insensitiven Pfad zurückgefallen.
+     */
+    flowSensitive?: boolean;
+}
+/**
+ * Build a process env from TI text and the process's parameter names.
+ * Processes assignments top-down; multi-assignments are demoted to dynamic.
+ *
+ * Overloads:
+ *   buildProcessEnv(text, paramNames)
+ *   buildProcessEnv(text, paramNames, stopAtLine)     — legacy positional
+ *   buildProcessEnv(text, paramNames, options)
+ */
+export declare function buildProcessEnv(text: string, paramNames: string[], stopAtLineOrOptions?: number | BuildEnvOptions): ProcessEnv;
+export declare function bindingsEqual(a: VarBinding, b: VarBinding): boolean;
+//# sourceMappingURL=variableEnv.d.ts.map

package/dist/lib/callgraph/variableEnv.js

@@ -0,0 +1,214 @@
+/**
+ * Per-process variable environment.
+ *
+ * Classifies each assignment `var = expression;` as
+ *   - literal    (string literal or numeric literal)
+ *   - param      (reference to a process parameter, directly or via another local variable that is a param)
+ *   - datasource (reference to a DataSource variable whose value comes from the source data at runtime)
+ *   - dynamic    (everything else — CellGet, concatenation, function calls, IF, loops)
+ *
+ * Multi-assignment (a variable is assigned different values) → dynamic,
+ * because the value is no longer unambiguous at any given call site.
+ */
+const STRING_LITERAL_RE = /^'([^']*)'$/;
+const NUMERIC_LITERAL_RE = /^-?\d+(?:\.\d+)?$/;
+const IDENTIFIER_RE = /^[A-Za-z_]\w*$/;
+function neutralizeLine(line) {
+    return line
+        .replace(/'[^']*'/g, (s) => " ".repeat(s.length))
+        .replace(/#.*$/, "");
+}
+const SECTION_MARKER_RE = /^57[2345],\d*$/;
+/**
+ * Split an expression on top-level '|' (TI string-concat), ignoring '|' inside
+ * 'string literals' or (parens). A single-element result means no top-level '|'
+ * was found (not a concatenation).
+ */
+function splitTopLevelConcat(expr) {
+    const parts = [];
+    let cur = "";
+    let inStr = false;
+    let depth = 0;
+    for (const ch of expr) {
+        if (ch === "'") {
+            inStr = !inStr;
+            cur += ch;
+        }
+        else if (!inStr && ch === "(") {
+            depth++;
+            cur += ch;
+        }
+        else if (!inStr && ch === ")") {
+            depth--;
+            cur += ch;
+        }
+        else if (!inStr && depth === 0 && ch === "|") {
+            parts.push(cur);
+            cur = "";
+        }
+        else {
+            cur += ch;
+        }
+    }
+    parts.push(cur);
+    return parts;
+}
+/**
+ * Classify a single right-hand-side expression (no surrounding whitespace).
+ * Only handles simple cases:
+ *   'literal', 42, varName (→ lookup), paramName (→ param-ref), dsVarName (→ datasource-ref).
+ * Constant string-concatenation (all operands resolve to literals) folds to a literal.
+ * Everything else (function calls, concatenation with any non-literal operand, arithmetic, IF, brackets) → dynamic.
+ */
+export function resolveExpression(expr, env) {
+    const e = expr.trim().replace(/;+$/, "").trim();
+    // String literal
+    const strM = STRING_LITERAL_RE.exec(e);
+    if (strM) {
+        return { kind: "literal", value: strM[1] };
+    }
+    // Numeric literal
+    if (NUMERIC_LITERAL_RE.test(e)) {
+        return { kind: "literal", value: e };
+    }
+    // Bare identifier — could be param, a DataSource var, or a previously-assigned local var
+    if (IDENTIFIER_RE.test(e)) {
+        const lc = e.toLowerCase();
+        if (env.paramsLc.has(lc)) {
+            return {
+                kind: "param",
+                paramName: env.paramOriginal.get(lc) ?? e,
+                paramType: env.paramTypes.get(lc),
+            };
+        }
+        const ds = env.datasourceVars.get(lc);
+        if (ds) {
+            return { kind: "datasource", varName: ds.name, varType: ds.type };
+        }
+        const bound = env.vars.get(lc);
+        if (bound) {
+            return bound;
+        }
+        // Unknown identifier — treat as dynamic (could be a global, a later-assigned var, etc.)
+        return { kind: "dynamic" };
+    }
+    // Constant string-concatenation: fold if every operand resolves to a literal.
+    const parts = splitTopLevelConcat(e);
+    if (parts.length >= 2) {
+        const values = [];
+        for (const part of parts) {
+            const resolved = resolveExpression(part, env);
+            if (resolved.kind !== "literal") {
+                return { kind: "dynamic" };
+            }
+            values.push(resolved.value);
+        }
+        return { kind: "literal", value: values.join("") };
+    }
+    return { kind: "dynamic" };
+}
+/**
+ * Build a process env from TI text and the process's parameter names.
+ * Processes assignments top-down; multi-assignments are demoted to dynamic.
+ *
+ * Overloads:
+ *   buildProcessEnv(text, paramNames)
+ *   buildProcessEnv(text, paramNames, stopAtLine)     — legacy positional
+ *   buildProcessEnv(text, paramNames, options)
+ */
+export function buildProcessEnv(text, paramNames, stopAtLineOrOptions) {
+    const opts = typeof stopAtLineOrOptions === "number"
+        ? { stopAtLine: stopAtLineOrOptions }
+        : (stopAtLineOrOptions ?? {});
+    const paramsLc = new Set(paramNames.map((p) => p.toLowerCase()));
+    const paramOriginal = new Map(paramNames.map((p) => [p.toLowerCase(), p]));
+    const paramTypes = opts.paramTypes ?? new Map();
+    const datasourceVars = new Map();
+    for (const dv of opts.datasourceVars ?? []) {
+        datasourceVars.set(dv.name.toLowerCase(), { name: dv.name, type: dv.type });
+    }
+    const env = {
+        paramsLc,
+        paramOriginal,
+        paramTypes,
+        datasourceVars,
+        vars: new Map(),
+    };
+    const assignedOnce = new Map();
+    const seen = new Set();
+    const assignRe = /^\s*([A-Za-z_]\w*)\s*=\s*(.+?)\s*;?\s*(?:#.*)?$/;
+    const lines = text.split("\n");
+    const limit = opts.stopAtLine !== undefined
+        ? Math.min(opts.stopAtLine, lines.length)
+        : lines.length;
+    for (let i = 0; i < limit; i++) {
+        const raw = lines[i];
+        const line = raw.replace(/\r$/, "");
+        if (SECTION_MARKER_RE.test(line.trim()) || line.trim() === "") {
+            continue;
+        }
+        // Skip comment-only lines
+        if (neutralizeLine(line).trim() === "") {
+            continue;
+        }
+        // Skip if line does not look like a pure assignment (contains `==` or similar comparisons in condition context)
+        const m = assignRe.exec(line);
+        if (!m) {
+            continue;
+        }
+        const varName = m[1];
+        const rhs = m[2];
+        // Exclude cases where rhs starts with `=` (meaning `==` comparison) — already filtered by regex `=\s*(.+)` non-greedy
+        // but `a == b` would match with varName='a' and rhs='= b'. Guard:
+        if (rhs.startsWith("=")) {
+            continue;
+        }
+        const lc = varName.toLowerCase();
+        // Never shadow a param name as a local var — a param reference of itself stays a param
+        if (paramsLc.has(lc)) {
+            continue;
+        }
+        // DataSource-Vars bleiben als solche erhalten — lokale Zuweisung mit demselben Namen wäre unüblich,
+        // wir ignorieren sie um die „Herkunft aus der DataSource" sichtbar zu halten.
+        if (datasourceVars.has(lc)) {
+            continue;
+        }
+        const binding = resolveExpression(rhs, env);
+        if (opts.lastAssignmentWins) {
+            // Jüngste Zuweisung überschreibt — passt zur Sicht „Wert direkt vor Zeile N".
+            assignedOnce.set(lc, binding);
+            env.vars.set(lc, binding);
+        }
+        else if (seen.has(lc)) {
+            const prev = assignedOnce.get(lc);
+            if (prev && !bindingsEqual(prev, binding)) {
+                // Konservativ: Multi-Assign mit unterschiedlichen Bindungen → dynamic.
+                assignedOnce.set(lc, { kind: "dynamic" });
+                env.vars.set(lc, { kind: "dynamic" });
+            }
+            // else: identische Bindung, Zustand bleibt
+        }
+        else {
+            seen.add(lc);
+            assignedOnce.set(lc, binding);
+            env.vars.set(lc, binding);
+        }
+    }
+    return env;
+}
+export function bindingsEqual(a, b) {
+    if (a.kind !== b.kind) {
+        return false;
+    }
+    if (a.kind === "literal" && b.kind === "literal") {
+        return a.value === b.value;
+    }
+    if (a.kind === "param" && b.kind === "param") {
+        return a.paramName.toLowerCase() === b.paramName.toLowerCase();
+    }
+    if (a.kind === "datasource" && b.kind === "datasource") {
+        return a.varName.toLowerCase() === b.varName.toLowerCase();
+    }
+    return a.kind === "dynamic";
+}
+//# sourceMappingURL=variableEnv.js.map

package/dist/lib/cell-address.d.ts

@@ -0,0 +1,12 @@
+export declare const SANDBOX_DIMENSION = "Sandboxes";
+export declare const BASE_SANDBOX = "Base";
+export interface ResolvedAddress {
+    /** The cube's dimensions, in cube order. */
+    dimensions: string[];
+    /** Maps a caller's elements (in the caller's dimension order) to cube order. */
+    toCubeOrder: (elements: readonly string[]) => string[];
+    /** Set when `Sandboxes` was left out and bound to `Base`. */
+    sandboxDefaulted?: typeof BASE_SANDBOX;
+}
+export declare function resolveCellAddress(cubeName: string, cubeDimensions: readonly string[], given: readonly string[]): ResolvedAddress;
+//# sourceMappingURL=cell-address.d.ts.map

package/dist/lib/cell-address.js

@@ -0,0 +1,71 @@
+// Resolve a caller's named-dimension cell address against the cube's real
+// dimension list, before anything is written. Shared by tm1_write_cells and
+// tm1_check_writable_coords so the pre-write check and the write agree on
+// which cell a coordinate means.
+//
+// Why: the write path builds an MDX tuple over the dimensions the caller
+// names, and TM1 fills every dimension left out with its default member —
+// without an error. Verified on 11.8.03500: a write that left out a measure
+// dimension landed on its first element and overwrote a value there.
+//
+// The one dimension that may be left out is the `Sandboxes` dimension that
+// `EnableSandboxDimension=true` adds to every cube: callers rarely think of it
+// as part of the cube. It is bound to `Base` explicitly rather than left to
+// TM1's default member, because the default is only known to be `Base` while
+// `Base` is the dimension's sole member — a sandbox with
+// IncludeInSandboxDimension=true adds another. This server never sends
+// `!sandbox=`, so `Base` is also what every read through it sees. A cube with
+// a regular dimension that happens to be named Sandboxes but has no `Base`
+// fails loudly with TM1's "member not found", never silently.
+import { TM1Error, TM1ErrorCode } from "../types.js";
+export const SANDBOX_DIMENSION = "Sandboxes";
+export const BASE_SANDBOX = "Base";
+export function resolveCellAddress(cubeName, cubeDimensions, given) {
+    const byLower = new Map(cubeDimensions.map((d, i) => [d.toLowerCase(), i]));
+    const positions = [];
+    const unknown = [];
+    const duplicate = [];
+    const seen = new Set();
+    for (const name of given) {
+        const pos = byLower.get(name.toLowerCase());
+        if (pos === undefined)
+            unknown.push(name);
+        else if (seen.has(pos))
+            duplicate.push(name);
+        else
+            seen.add(pos);
+        positions.push(pos ?? -1);
+    }
+    const missing = cubeDimensions.filter((_, i) => !seen.has(i));
+    const sandboxPos = cubeDimensions.findIndex((d) => d.toLowerCase() === SANDBOX_DIMENSION.toLowerCase());
+    const onlySandboxMissing = missing.length === 1 && sandboxPos >= 0 && !seen.has(sandboxPos);
+    const problems = [];
+    if (unknown.length > 0)
+        problems.push(`not in the cube: ${unknown.join(", ")}`);
+    if (duplicate.length > 0)
+        problems.push(`listed twice: ${duplicate.join(", ")}`);
+    if (missing.length > 0 && !onlySandboxMissing)
+        problems.push(`missing: ${missing.filter((d) => d !== cubeDimensions[sandboxPos]).join(", ")}`);
+    if (problems.length > 0) {
+        throw new TM1Error({
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Dimensions do not match cube '${cubeName}' — ${problems.join("; ")}. Nothing was written.`,
+            hint: `Name every dimension of the cube (any order): ${cubeDimensions.join(", ")}. A dimension left out is not ignored — TM1 writes into its default member.${sandboxPos >= 0 ? ` Only ${SANDBOX_DIMENSION} may be left out; it is then bound to ${BASE_SANDBOX}.` : ""}`,
+            details: JSON.stringify({ cubeDimensions, given }),
+        });
+    }
+    return {
+        dimensions: [...cubeDimensions],
+        toCubeOrder: (elements) => {
+            const out = new Array(cubeDimensions.length);
+            elements.forEach((e, i) => {
+                out[positions[i]] = e;
+            });
+            if (onlySandboxMissing)
+                out[sandboxPos] = BASE_SANDBOX;
+            return out;
+        },
+        ...(onlySandboxMissing ? { sandboxDefaulted: BASE_SANDBOX } : {}),
+    };
+}
+//# sourceMappingURL=cell-address.js.map

package/dist/lib/complexity/antipatterns.d.ts

@@ -0,0 +1,22 @@
+import type { ProcessCodeInput, TiTab } from "./process-metrics.js";
+export type Severity = "error" | "warn" | "info";
+export interface Finding {
+    process: string;
+    tab: TiTab;
+    line: number;
+    rule: string;
+    severity: Severity;
+    snippet: string;
+    hint: string;
+}
+export interface LintOptions {
+    /** Element-arg count at/above which CellGetN/S is flagged as perf-risky. */
+    cellGetDimThreshold?: number | undefined;
+    /**
+     * Additional variable names (case-insensitive) to exclude from dead-assignment
+     * detection — pass process parameters and datasource column variable names here.
+     */
+    excludeVarsFromDeadCheck?: string[] | undefined;
+}
+export declare function lintProcess(process: string, code: ProcessCodeInput, opts?: LintOptions): Finding[];
+//# sourceMappingURL=antipatterns.d.ts.map