@ffschrattenecker/tm1-mcp-server 6.0.0

package/dist/lib/callgraph/dataFlow.js

@@ -0,0 +1,271 @@
+// Pure data-flow tracer for tm1_trace_data_flow. No I/O.
+//
+// Combines the reference index (code-level CellGet/CellPut/DB cube access,
+// already classified read/write) with a per-process datasource list (to catch
+// reads that flow through a TM1CubeView datasource and leave no CellGet in the
+// code). Answers, for one cube:
+//   downstream — processes that READ it, and which cubes they WRITE to.
+//   upstream   — processes that WRITE it, and where they SOURCE their data.
+import { elementKey } from "./referenceIndex.js";
+import { classifyAccess } from "./callGraph.js";
+const lc = (s) => s.toLowerCase();
+/** Build per-process cube read/write sets from the index + datasource list. */
+function buildProcessIO(index, dsList, cubeOrig) {
+    const io = new Map();
+    const get = (name) => {
+        const key = lc(name);
+        let e = io.get(key);
+        if (!e) {
+            e = {
+                orig: name,
+                reads: new Set(),
+                writes: new Set(),
+                readsViaCode: false,
+                readsViaDatasource: false,
+                dsType: "None",
+            };
+            io.set(key, e);
+        }
+        return e;
+    };
+    // Datasource pass: every process, even ones with no cube code-refs.
+    for (const ds of dsList) {
+        const e = get(ds.name);
+        e.dsType = ds.type;
+        if (ds.type === "TM1CubeView" && ds.sourceName) {
+            const cubeLc = lc(ds.sourceName);
+            e.reads.add(cubeLc);
+            e.readsViaDatasource = true;
+            e.dsSourceCube = cubeLc;
+            if (!cubeOrig.has(cubeLc))
+                cubeOrig.set(cubeLc, ds.sourceName);
+        }
+        else if (ds.type === "ASCII") {
+            e.externalSource = "ASCII file";
+        }
+        else if (ds.type === "ODBC") {
+            e.externalSource = "ODBC";
+        }
+        else if (ds.type === "TM1Process" && ds.sourceName) {
+            e.externalSource = `process:${ds.sourceName}`;
+        }
+        else if (ds.type === "TM1DimensionSubset" && ds.sourceName) {
+            e.externalSource = `subset:${ds.sourceName}`;
+        }
+    }
+    // Code pass: classified cube reads/writes from the reference index.
+    for (const r of index.all) {
+        if (r.sourceKind !== "process" || r.targetKind !== "cube")
+            continue;
+        const access = classifyAccess(r.funcName, "process");
+        if (access === "other")
+            continue;
+        const e = get(r.sourceName);
+        const cubeLc = lc(r.targetName);
+        if (!cubeOrig.has(cubeLc))
+            cubeOrig.set(cubeLc, r.targetName);
+        if (access === "read") {
+            e.reads.add(cubeLc);
+            e.readsViaCode = true;
+        }
+        else {
+            e.writes.add(cubeLc);
+        }
+    }
+    return io;
+}
+/** In-code subset-membership element names a process manipulates, sorted & de-duped. */
+function elementsForProcess(index, processOrig) {
+    const refs = index.bySourceProcess.get(processOrig.toLowerCase()) ?? [];
+    const names = new Set();
+    for (const r of refs) {
+        if (r.targetKind === "element")
+            names.add(r.targetName);
+    }
+    return [...names].sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Classify how a process accesses a traced element, joining in-code subset usage
+ * (view-assign / zero-out / loop, from subsetUsageByProcess) with the process's own
+ * datasource (dsList). `subsetsForElement` are the lowercased subset handles the
+ * element was inserted into, within this one process. 'indeterminate' means the
+ * subset was built but no downstream use could be classified — NOT proof of no use
+ * (stored view/subset MDX outside this process is Bucket B, not resolved here).
+ */
+function classifyElementAccess(usageForProcess, subsetsForElement, ds, tracedDimension) {
+    const kinds = new Set();
+    for (const subLc of subsetsForElement) {
+        const u = usageForProcess?.get(subLc);
+        if (ds?.type === "TM1DimensionSubset" &&
+            ds.subset?.toLowerCase() === subLc &&
+            ds.sourceName?.toLowerCase() === tracedDimension.toLowerCase())
+            kinds.add("source");
+        if (u) {
+            for (const v of u.views) {
+                if (v.zeroOut)
+                    kinds.add("zero-out");
+                if (ds?.type === "TM1CubeView" &&
+                    v.view &&
+                    v.cube &&
+                    ds.view?.toLowerCase() === v.view.toLowerCase() &&
+                    ds.sourceName?.toLowerCase() === v.cube.toLowerCase())
+                    kinds.add("source");
+            }
+            if (u.loopRead)
+                kinds.add("source");
+            if (u.loopZero)
+                kinds.add("zero-out");
+            else if (u.loopWrite)
+                kinds.add("write");
+        }
+    }
+    if (kinds.size === 0)
+        kinds.add("indeterminate");
+    return [...kinds].sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Trace data flow into/out of a cube. Case-insensitive cube matching; output
+ * preserves original casing. Lists are sorted by process name.
+ */
+export function traceDataFlow(index, dsList, cubeName, direction, opts) {
+    const cubeOrig = new Map();
+    const io = buildProcessIO(index, dsList, cubeOrig);
+    const targetLc = lc(cubeName);
+    const canonical = cubeOrig.get(targetLc) ?? cubeName;
+    const cubeLabel = (l) => cubeOrig.get(l) ?? l;
+    const result = { cube: canonical, direction, counts: {} };
+    if (direction === "downstream" || direction === "both") {
+        const readers = [];
+        for (const e of io.values()) {
+            if (!e.reads.has(targetLc))
+                continue;
+            const targetCubes = [...e.writes]
+                .filter((c) => c !== targetLc)
+                .map(cubeLabel)
+                .sort((a, b) => a.localeCompare(b));
+            const readsVia = e.readsViaCode && e.readsViaDatasource
+                ? "both"
+                : e.readsViaCode
+                    ? "code"
+                    : "datasource";
+            const elements = elementsForProcess(index, e.orig);
+            readers.push({
+                process: e.orig,
+                targetCubes,
+                readsVia,
+                ...(elements.length ? { elements } : {}),
+            });
+        }
+        readers.sort((a, b) => a.process.localeCompare(b.process));
+        result.downstream = readers;
+        result.counts.downstream = readers.length;
+    }
+    if (direction === "upstream" || direction === "both") {
+        const writers = [];
+        for (const e of io.values()) {
+            if (!e.writes.has(targetLc))
+                continue;
+            const sourceCubes = [...e.reads]
+                .filter((c) => c !== targetLc)
+                .map(cubeLabel)
+                .sort((a, b) => a.localeCompare(b));
+            const elements = elementsForProcess(index, e.orig);
+            writers.push({
+                process: e.orig,
+                sourceCubes,
+                datasourceType: e.dsType,
+                ...(e.externalSource ? { externalSource: e.externalSource } : {}),
+                ...(elements.length ? { elements } : {}),
+            });
+        }
+        writers.sort((a, b) => a.process.localeCompare(b.process));
+        result.upstream = writers;
+        result.counts.upstream = writers.length;
+    }
+    if (opts?.element) {
+        const { dimension, name } = opts.element;
+        const key = elementKey(dimension, name);
+        const wanted = new Set(opts.elementAccess ?? ["source", "write", "zero-out"]);
+        // in-code (Phase 1/1.5): funcNames + subsets per process
+        const perProc = new Map();
+        for (const r of index.byElement.get(key) ?? []) {
+            const e = perProc.get(r.sourceName) ?? {
+                funcNames: new Set(),
+                subsets: new Set(),
+            };
+            if (r.funcName)
+                e.funcNames.add(r.funcName);
+            if (r.subset)
+                e.subsets.add(r.subset.toLowerCase());
+            perProc.set(r.sourceName, e);
+        }
+        // Bucket B: stored view/subset datasource membership → via tags per process (a datasource IS a read).
+        const dsVia = new Map();
+        for (const hit of opts.datasourceMembership?.byElement.get(key) ?? []) {
+            const set = dsVia.get(hit.process) ?? new Set();
+            set.add(hit.via);
+            dsVia.set(hit.process, set);
+        }
+        const dsByProc = new Map();
+        for (const d of dsList)
+            dsByProc.set(d.name.toLowerCase(), d);
+        const allProcs = new Set([...perProc.keys(), ...dsVia.keys()]);
+        let suppressedIndeterminate = 0;
+        const processes = [];
+        for (const process of allProcs) {
+            const e = perProc.get(process);
+            const usage = index.subsetUsageByProcess.get(process.toLowerCase());
+            const accessSet = new Set(e
+                ? classifyElementAccess(usage, [...e.subsets], dsByProc.get(process.toLowerCase()), dimension)
+                : []);
+            const via = [...(dsVia.get(process) ?? [])].sort((a, b) => a.localeCompare(b));
+            if (via.length)
+                accessSet.add("source"); // stored view/subset datasource = read
+            if (accessSet.size === 0)
+                accessSet.add("indeterminate");
+            const access = [...accessSet].sort((a, b) => a.localeCompare(b));
+            if (!access.some((a) => wanted.has(a))) {
+                if (access.length === 1 && access[0] === "indeterminate")
+                    suppressedIndeterminate++;
+                continue;
+            }
+            const funcNames = [...(e?.funcNames ?? [])].sort((a, b) => a.localeCompare(b));
+            processes.push(via.length
+                ? { process, funcNames, access, via }
+                : { process, funcNames, access });
+        }
+        processes.sort((a, b) => a.process.localeCompare(b.process));
+        const unresolvedInProcesses = [
+            ...index.unresolvedElementRefsBySourceProcess.entries(),
+        ]
+            .filter(([, list]) => list.some((u) => (u.dimension ?? "").toLowerCase() === dimension.toLowerCase()))
+            .map(([proc]) => proc)
+            .sort((a, b) => a.localeCompare(b));
+        // Scope to the traced dimension: a process is only noise-flagged if it has a computed
+        // selector on THIS dimension, or an unscoped ("*") one (whole-MDX-VIEW datasource, not
+        // tied to a single axis). Excludes processes whose computed selectors are on other axes
+        // (e.g. a computed [Time] selector must not surface while tracing a [Region] element).
+        const dimLc = dimension.toLowerCase();
+        const computedInProcesses = [
+            ...(opts.datasourceMembership?.computedByProcess.entries() ?? []),
+        ]
+            .filter(([, byDim]) => byDim.has(dimLc) || byDim.has("*"))
+            .map(([proc]) => proc)
+            .sort((a, b) => a.localeCompare(b));
+        const fetchErrorCount = opts.datasourceMembership?.fetchErrors.length ?? 0;
+        result.element = {
+            dimension,
+            name,
+            processes,
+            ...(unresolvedInProcesses.length ? { unresolvedInProcesses } : {}),
+            ...(suppressedIndeterminate ? { suppressedIndeterminate } : {}),
+            ...(computedInProcesses.length ? { computedInProcesses } : {}),
+            resolution: "access from in-code subset usage (view-assign/zero-out/loop) + datasource; stored view/subset datasources resolved (native-title/static exact, MDX by literal member); computed selectors (TM1FILTERBY*/DESCENDANTS/…) flagged in computedInProcesses, not resolved; 'indeterminate' = built but not classifiable, not evidence the element goes untouched." +
+                (fetchErrorCount
+                    ? ` (${fetchErrorCount} datasource object(s) could not be fetched — results may be incomplete)`
+                    : ""),
+        };
+    }
+    return result;
+}
+//# sourceMappingURL=dataFlow.js.map

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

@@ -0,0 +1,31 @@
+import { type ViewDefinition, type Subset } from "../../types.js";
+import type { DataSourceEntry } from "./dataFlow.js";
+export type MembershipVia = "view-mdx" | "view-native-title" | "view-native-expr" | "view-native-computed" | "subset-static" | "subset-mdx";
+export interface DatasourceMembership {
+    /** elementKey(dim, element) → processes that reach it through a datasource object. */
+    byElement: Map<string, Array<{
+        process: string;
+        via: MembershipVia;
+    }>>;
+    /**
+     * process → dimension (lowercased) → computed MDX selectors encountered
+     * (Bucket C boundary; element identity not literal). The dimension key is
+     * "*" when a selector cannot be tied to one axis/subset dimension (a
+     * whole-MDX-VIEW datasource) — callers should treat "*" as unscoped/matches-any.
+     */
+    computedByProcess: Map<string, Map<string, Set<string>>>;
+    /** per-object fetch failures (non-systemic); systemic errors are re-thrown. */
+    fetchErrors: Array<{
+        process: string;
+        object: string;
+        message: string;
+    }>;
+}
+export interface MembershipDeps {
+    getViewDefinition(cube: string, view: string): Promise<ViewDefinition>;
+    getSubset(dimension: string, hierarchy: string, subset: string): Promise<Subset>;
+    /** C1 (opt-in): resolve a computed axis set to its concrete member names, already scoped to `dimension`. */
+    evaluateSetExpression?(cube: string, dimension: string, mdxSet: string): Promise<string[]>;
+}
+export declare function buildDatasourceMembership(deps: MembershipDeps, dsList: DataSourceEntry[]): Promise<DatasourceMembership>;
+//# sourceMappingURL=datasourceMembership.d.ts.map

package/dist/lib/callgraph/datasourceMembership.js

@@ -0,0 +1,142 @@
+import { TM1Error } from "../../types.js";
+import { elementKey } from "./referenceIndex.js";
+import { extractMdxMemberRefs } from "./mdxMembers.js";
+import { rethrowIfSystemic } from "../../tm1-client/services/fallback.js";
+export async function buildDatasourceMembership(deps, dsList) {
+    const byElement = new Map();
+    const computedByProcess = new Map();
+    const fetchErrors = [];
+    // C1: per-run cache keyed by (cube, lowercased expression) — avoids re-evaluating a shared axis
+    // (cosmetically-different-cased identical sets share the cache; members still added with real casing).
+    const evalCache = new Map();
+    const addMember = (process, dim, el, via) => {
+        const k = elementKey(dim, el);
+        const arr = byElement.get(k) ?? [];
+        if (!arr.some((e) => e.process === process && e.via === via))
+            arr.push({ process, via });
+        byElement.set(k, arr);
+    };
+    /** dim: owning dimension of the computed selector, or "*" when it cannot be tied to one axis (whole-MDX-VIEW). */
+    const addComputed = (process, dim, names) => {
+        if (names.length === 0)
+            return;
+        const dimLc = dim.toLowerCase();
+        const byDim = computedByProcess.get(process) ?? new Map();
+        const set = byDim.get(dimLc) ?? new Set();
+        for (const n of names)
+            set.add(n);
+        byDim.set(dimLc, set);
+        computedByProcess.set(process, byDim);
+    };
+    const addMdx = (process, mdx, via, dim) => {
+        const { members, computedSelectors } = extractMdxMemberRefs(mdx);
+        for (const ref of members)
+            addMember(process, ref.dimension, ref.element, via);
+        addComputed(process, dim, computedSelectors);
+    };
+    const applySubset = (process, sub) => {
+        if (sub.elements.length > 0) {
+            for (const el of sub.elements)
+                addMember(process, sub.dimensionName, el, "subset-static");
+        }
+        else if (sub.expression) {
+            addMdx(process, sub.expression, "subset-mdx", sub.dimensionName);
+        }
+    };
+    for (const ds of dsList) {
+        try {
+            if (ds.type === "TM1CubeView" && ds.sourceName && ds.view) {
+                const def = await deps.getViewDefinition(ds.sourceName, ds.view);
+                if (def.type === "MDX" && def.mdx) {
+                    // Whole-MDX-VIEW datasource: not tied to a single axis/dimension — unscoped sentinel.
+                    addMdx(ds.name, def.mdx, "view-mdx", "*");
+                }
+                else if (def.type === "Native" && def.native) {
+                    // Titles are pinned to exactly ONE member (selectedElement). TM1's
+                    // getDefinition also populates a title's subsetName (the subset the
+                    // pin was chosen from), but enumerating that subset would falsely
+                    // report every non-selected element as read. So titles contribute
+                    // ONLY the selected member — never expression/subsetName enumeration.
+                    for (const title of def.native.titles) {
+                        if (title.selectedElement && title.dimensionName) {
+                            addMember(ds.name, title.dimensionName, title.selectedElement, "view-native-title");
+                        }
+                    }
+                    // Columns/rows iterate their full axis — every member is read.
+                    const axes = [...def.native.columns, ...def.native.rows];
+                    for (const ax of axes) {
+                        if (ax.expression) {
+                            const { members, computedSelectors } = extractMdxMemberRefs(ax.expression);
+                            for (const ref of members)
+                                addMember(ds.name, ref.dimension, ref.element, "view-native-expr");
+                            addComputed(ds.name, ax.dimensionName ?? "*", computedSelectors);
+                            // C1: if this axis is computed and a resolver is provided, resolve it exactly.
+                            if (computedSelectors.length > 0 &&
+                                deps.evaluateSetExpression &&
+                                ax.dimensionName) {
+                                const cacheKey = `${ds.sourceName.toLowerCase()} ${ax.expression.toLowerCase()}`;
+                                let names = evalCache.get(cacheKey);
+                                if (names === undefined) {
+                                    try {
+                                        names = await deps.evaluateSetExpression(ds.sourceName, ax.dimensionName, ax.expression);
+                                        evalCache.set(cacheKey, names);
+                                    }
+                                    catch (evalErr) {
+                                        if (evalErr instanceof TM1Error)
+                                            rethrowIfSystemic(evalErr);
+                                        fetchErrors.push({
+                                            process: ds.name,
+                                            object: `eval ${ds.sourceName}/${ax.dimensionName}`,
+                                            message: evalErr instanceof Error
+                                                ? evalErr.message
+                                                : String(evalErr),
+                                        });
+                                        names = undefined;
+                                    }
+                                }
+                                if (names) {
+                                    for (const name of names)
+                                        addMember(ds.name, ax.dimensionName, name, "view-native-computed");
+                                }
+                            }
+                        }
+                        else if (ax.subsetName && ax.dimensionName) {
+                            const sub = await deps.getSubset(ax.dimensionName, ax.hierarchyName ?? ax.dimensionName, ax.subsetName);
+                            applySubset(ds.name, sub);
+                        }
+                    }
+                }
+            }
+            else if (ds.type === "TM1DimensionSubset" &&
+                ds.subset &&
+                ds.sourceName) {
+                const dim = ds.sourceName; // dataSourceNameForServer — the dimension (verify live, Task 4)
+                const sub = await deps.getSubset(dim, dim, ds.subset);
+                applySubset(ds.name, sub);
+            }
+        }
+        catch (e) {
+            // rethrowIfSystemic classifies AUTH_FAILED/CONNECTION_FAILED/LOCK_TIMEOUT
+            // TM1Errors as systemic (must propagate) and returns for expected
+            // handleable TM1Errors (e.g. NOT_FOUND). It also rethrows any
+            // non-TM1Error by design (fallback.ts: "programming errors, unexpected
+            // throws" must never be swallowed by generic REST-fallback call sites).
+            // Here the per-object fetch loop's contract is broader: ANY per-object
+            // failure (TM1Error or not) is recorded, not thrown — only genuinely
+            // systemic TM1Errors propagate. So only route TM1Error through the
+            // shared systemic guard; non-TM1Error falls straight to fetchErrors.
+            if (e instanceof TM1Error)
+                rethrowIfSystemic(e);
+            const object = ds.type === "TM1CubeView"
+                ? `view ${ds.sourceName}/${ds.view}`
+                : `subset ${ds.sourceName}/${ds.subset}`;
+            fetchErrors.push({
+                process: ds.name,
+                object,
+                message: e instanceof Error ? e.message : String(e),
+            });
+        }
+    }
+    return { byElement, computedByProcess, fetchErrors };
+}
+//# sourceMappingURL=datasourceMembership.js.map

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

@@ -0,0 +1,28 @@
+/** Severity of a lint diagnostic */
+export type LintSeverity = "error" | "warning" | "hint";
+/** TM1 process section */
+export type TiSection = "prolog" | "metadata" | "data" | "epilog";
+/** All known rule IDs of the TI linter */
+export type LintRuleId = "endless-loop" | "wrong-arg-count" | "string-compare-without-at" | "numeric-compare-with-at" | "type-mismatch-assignment" | "wrong-param-type" | "unused-variable" | "dead-store" | "empty-if" | "empty-while" | "cellput-no-error-handling" | "unknown-function" | "missing-semicolon" | "wrong-section" | "undefined-variable" | "v12-deprecated" | "ti-unknown-cube" | "ti-unknown-dimension" | "dead-code-condition" | "tm1-error-code" | "performance-hint";
+/** A single lint diagnostic */
+export interface LintDiagnose {
+    /** 1-based line number */
+    line: number;
+    /** Severity */
+    severity: LintSeverity;
+    /** Rule ID */
+    ruleId: LintRuleId;
+    /** Error message with rule-ID prefix: [rule-id] message */
+    message: string;
+}
+/** Data type of a TI variable */
+export type VariableType = "string" | "numeric";
+/** Information about an inferred variable */
+export interface VariableInfo {
+    type: VariableType;
+    /** Line of the first assignment */
+    firstAssignmentLine: number;
+}
+/** Key: variable name in lowercase */
+export type VariableTypeMap = Map<string, VariableInfo>;
+//# sourceMappingURL=lintTypes.d.ts.map

package/dist/lib/callgraph/lintTypes.js

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

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

@@ -0,0 +1,29 @@
+export interface MdxMemberRef {
+    dimension: string;
+    element: string;
+}
+export interface MdxExtractResult {
+    members: MdxMemberRef[];
+    computedSelectors: string[];
+}
+/** MDX set functions that compute membership without naming elements (Bucket C boundary). */
+export declare const MDX_COMPUTED_FUNCS: ReadonlySet<string>;
+export declare function extractMdxMemberRefs(mdx: string): MdxExtractResult;
+/**
+ * Pure member-extraction step for a live executeMdx result: picks axis-0 tuple
+ * member names belonging to one dimension's hierarchy. Used by the C1
+ * (resolveComputed) path in tm1_trace_data_flow, which builds the
+ * `SELECT {expr} ON 0 FROM [cube]` MDX and calls executeMdx itself — this
+ * just filters/flattens the response so that glue stays inline at the call site.
+ */
+export declare function membersFromAxis(res: {
+    axes?: Array<{
+        tuples: Array<{
+            members: Array<{
+                name: string;
+                hierarchyName?: string;
+            }>;
+        }>;
+    }>;
+}, dimension: string): string[];
+//# sourceMappingURL=mdxMembers.d.ts.map

package/dist/lib/callgraph/mdxMembers.js

@@ -0,0 +1,97 @@
+// Pure MDX member extractor: pulls literally-named [Dim].[...].[El] member
+// references out of an MDX string, and separately flags MDX set functions
+// that scope elements WITHOUT naming them (e.g. all leaves under a
+// dimension) so callers can report them as unresolved rather than imply
+// "no elements".
+/** MDX set functions that compute membership without naming elements (Bucket C boundary). */
+export const MDX_COMPUTED_FUNCS = new Set([
+    "TM1FILTERBYLEVEL",
+    "TM1FILTERBYPATTERN",
+    "TM1SUBSETALL",
+    "TM1DRILLDOWNMEMBER",
+    "DESCENDANTS",
+    "ANCESTORS",
+    "ANCESTOR",
+    "CHILDREN",
+    "MEMBERS",
+    "HIERARCHIZE",
+    "FILTER",
+    "TOPCOUNT",
+    "BOTTOMCOUNT",
+    "ORDER",
+    "EXCEPT",
+    "GENERATE",
+]);
+// One bracketed segment: [ ... ] where ]] is an escaped ]. A chain of >=2
+// segments separated by dots is a member path; a lone segment is a
+// dimension/hierarchy ref.
+const MEMBER_PATH_RE = /(\[(?:[^\]]|\]\])*\])(?:\s*\.\s*(\[(?:[^\]]|\]\])*\]))+/g;
+const SEGMENT_RE = /\[((?:[^\]]|\]\])*)\]/g;
+const FUNC_RE = /\b([A-Za-z_][A-Za-z0-9_]*)\s*\(/g;
+function unbracket(seg) {
+    // strip outer [ ], unescape ]] -> ]
+    return seg.slice(1, -1).replace(/\]\]/g, "]");
+}
+export function extractMdxMemberRefs(mdx) {
+    const members = [];
+    const seen = new Set();
+    let m;
+    MEMBER_PATH_RE.lastIndex = 0;
+    while ((m = MEMBER_PATH_RE.exec(mdx)) !== null) {
+        const chain = m[0];
+        SEGMENT_RE.lastIndex = 0;
+        const segs = [];
+        let s;
+        while ((s = SEGMENT_RE.exec(chain)) !== null) {
+            segs.push(unbracket(s[0]));
+        }
+        if (segs.length < 2)
+            continue;
+        // segs.length >= 2 is guaranteed by the check above, so both indices exist.
+        const dimension = segs[0];
+        const element = segs[segs.length - 1];
+        const key = `${dimension.toLowerCase()} ${element.toLowerCase()}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            members.push({ dimension, element });
+        }
+    }
+    const computedSelectors = [];
+    const seenFuncs = new Set();
+    FUNC_RE.lastIndex = 0;
+    let f;
+    while ((f = FUNC_RE.exec(mdx)) !== null) {
+        // f[1] is always present: FUNC_RE's single capture group is not optional.
+        const name = f[1].toUpperCase();
+        if (MDX_COMPUTED_FUNCS.has(name) && !seenFuncs.has(name)) {
+            seenFuncs.add(name);
+            computedSelectors.push(name);
+        }
+    }
+    return {
+        members,
+        computedSelectors: [...computedSelectors].sort((a, b) => a.localeCompare(b)),
+    };
+}
+/**
+ * Pure member-extraction step for a live executeMdx result: picks axis-0 tuple
+ * member names belonging to one dimension's hierarchy. Used by the C1
+ * (resolveComputed) path in tm1_trace_data_flow, which builds the
+ * `SELECT {expr} ON 0 FROM [cube]` MDX and calls executeMdx itself — this
+ * just filters/flattens the response so that glue stays inline at the call site.
+ */
+export function membersFromAxis(res, dimension) {
+    const axis0 = res.axes?.[0];
+    if (!axis0)
+        return [];
+    const wantHier = dimension.toLowerCase();
+    const names = [];
+    for (const t of axis0.tuples) {
+        for (const mem of t.members) {
+            if (mem.hierarchyName?.toLowerCase() === wantHier)
+                names.push(mem.name);
+        }
+    }
+    return names;
+}
+//# sourceMappingURL=mdxMembers.js.map