@ffschrattenecker/tm1-mcp-server 7.0.2 → 8.1.0

package/dist/tm1-client/services/view-service.js

@@ -8,8 +8,7 @@
 import { TM1Error, TM1ErrorCode } from "../../types.js";
 import { freeCellset, transformCellsetResponse } from "./cellset-transform.js";
 import { rethrowIfSystemicOrDenied } from "./fallback.js";
-// OData key encoder: double ' per OData literal rules, then percent-encode.
-const enc = (s) => encodeURIComponent(String(s).replace(/'/g, "''"));
+import { odataKey } from "./odata-page.js";
 export class ViewService {
     http;
     constructor(http) {
@@ -31,7 +30,7 @@ export class ViewService {
         // not an optimisation.
         const fetchScope = async (collection, isPrivate) => {
             try {
-                const res = await this.http.request("GET", `/api/v1/Cubes('${enc(cubeName)}')/${collection}?$select=Name,MDX`);
+                const res = await this.http.request("GET", `/api/v1/Cubes('${odataKey(cubeName)}')/${collection}?$select=Name,MDX`);
                 return res.value.map((v) => ({
                     name: v.Name,
                     mdx: v.MDX,
@@ -70,7 +69,7 @@ export class ViewService {
             cellsExpand += `;$skip=${skip}`;
         cellsExpand += ")";
         const axesExpand = "Axes($expand=Tuples($expand=Members($select=Name;$expand=Hierarchy($select=Name))))";
-        const path = `/api/v1/Cubes('${enc(cubeName)}')/Views('${enc(viewName)}')/tm1.Execute?$expand=${cellsExpand},${axesExpand}`;
+        const path = `/api/v1/Cubes('${odataKey(cubeName)}')/Views('${odataKey(viewName)}')/tm1.Execute?$expand=${cellsExpand},${axesExpand}`;
         const response = await this.http.request("POST", path, undefined, opts);
         try {
             const mdxResult = transformCellsetResponse(response);
@@ -97,7 +96,7 @@ export class ViewService {
      */
     async getDefinition(cubeName, viewName, isPrivate) {
         const fetchBase = async (segment) => {
-            const path = `/api/v1/Cubes('${enc(cubeName)}')/${segment}('${enc(viewName)}')?$select=Name,MDX`;
+            const path = `/api/v1/Cubes('${odataKey(cubeName)}')/${segment}('${odataKey(viewName)}')?$select=Name,MDX`;
             return this.http.request("GET", path);
         };
         const order = isPrivate === true
@@ -155,7 +154,7 @@ export class ViewService {
             `Columns/${subsetExpand}`,
             `Rows/${subsetExpand}`,
         ].join(",");
-        const nativePath = `/api/v1/Cubes('${enc(cubeName)}')/${resolvedSeg}('${enc(viewName)}')/tm1.NativeView?$expand=${nativeExpand}`;
+        const nativePath = `/api/v1/Cubes('${odataKey(cubeName)}')/${resolvedSeg}('${odataKey(viewName)}')/tm1.NativeView?$expand=${nativeExpand}`;
         let native;
         try {
             native = await this.http.request("GET", nativePath);
@@ -202,7 +201,7 @@ export class ViewService {
      * POST /api/v1/Cubes('{c}')/Views with @odata.type = #ibm.tm1.api.v1.MDXView
      */
     async createMdx(cubeName, viewName, mdx) {
-        await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/Views`, {
+        await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/Views`, {
             "@odata.type": "#ibm.tm1.api.v1.MDXView",
             Name: viewName,
             MDX: mdx,
@@ -216,7 +215,7 @@ export class ViewService {
      * POST /api/v1/Cubes('{c}')/Views with @odata.type = #ibm.tm1.api.v1.NativeView
      */
     async createNative(cubeName, viewName, spec) {
-        const hierPath = (a) => `Dimensions('${enc(a.dimension)}')/Hierarchies('${enc(a.hierarchy ?? a.dimension)}')`;
+        const hierPath = (a) => `Dimensions('${odataKey(a.dimension)}')/Hierarchies('${odataKey(a.hierarchy ?? a.dimension)}')`;
         const mapAxis = (a) => {
             const sources = [a.subset, a.expression, a.elements].filter((s) => s !== undefined);
             if (sources.length !== 1) {
@@ -229,7 +228,7 @@ export class ViewService {
             }
             if (a.subset !== undefined) {
                 return {
-                    "Subset@odata.bind": `${hierPath(a)}/Subsets('${enc(a.subset)}')`,
+                    "Subset@odata.bind": `${hierPath(a)}/Subsets('${odataKey(a.subset)}')`,
                 };
             }
             if (a.expression !== undefined) {
@@ -243,7 +242,7 @@ export class ViewService {
             return {
                 Subset: {
                     "Hierarchy@odata.bind": hierPath(a),
-                    "Elements@odata.bind": (a.elements ?? []).map((e) => `${hierPath(a)}/Elements('${enc(e)}')`),
+                    "Elements@odata.bind": (a.elements ?? []).map((e) => `${hierPath(a)}/Elements('${odataKey(e)}')`),
                 },
             };
         };
@@ -260,7 +259,7 @@ export class ViewService {
             }
             const axis = mapAxis(t);
             axis["Selected@odata.bind"] =
-                `${hierPath(t)}/Elements('${enc(t.selected)}')`;
+                `${hierPath(t)}/Elements('${odataKey(t.selected)}')`;
             return axis;
         };
         const body = {
@@ -274,14 +273,14 @@ export class ViewService {
         };
         if (spec.formatString !== undefined)
             body.FormatString = spec.formatString;
-        await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/Views`, body);
+        await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/Views`, body);
     }
     /**
      * Delete a public view from a cube.
      * DELETE /api/v1/Cubes('{c}')/Views('{v}')
      */
     async delete(cubeName, viewName) {
-        await this.http.request("DELETE", `/api/v1/Cubes('${enc(cubeName)}')/Views('${enc(viewName)}')`);
+        await this.http.request("DELETE", `/api/v1/Cubes('${odataKey(cubeName)}')/Views('${odataKey(viewName)}')`);
     }
 }
 //# sourceMappingURL=view-service.js.map

package/dist/tm1-client.js

@@ -6,6 +6,7 @@ import { DimensionService } from "./tm1-client/services/dimension-service.js";
 import { HierarchyService } from "./tm1-client/services/hierarchy-service.js";
 import { ElementService } from "./tm1-client/services/element-service.js";
 import { CellService } from "./tm1-client/services/cell-service.js";
+import { DimensionOrderCache } from "./tm1-client/services/dimension-order.js";
 import { ViewService } from "./tm1-client/services/view-service.js";
 import { SubsetService } from "./tm1-client/services/subset-service.js";
 import { ProcessService } from "./tm1-client/services/process-service.js";
@@ -53,10 +54,12 @@ export class TM1Client {
         // http.ts — now the coupling is a visible, idempotent call at construction.
         registerCallgraphCacheInvalidation();
         this.batch = new BatchService(this.http);
-        this.cubes = new CubeService(this.http);
+        // One dimension-order cache per connection, shared by cubes and cells.
+        const dimOrder = new DimensionOrderCache(this.http);
+        this.cubes = new CubeService(this.http, dimOrder);
         this.dimensions = new DimensionService(this.http);
         this.hierarchies = new HierarchyService(this.http);
-        this.cells = new CellService(this.http);
+        this.cells = new CellService(this.http, dimOrder);
         this.views = new ViewService(this.http);
         this.subsets = new SubsetService(this.http);
         // ElementService depends on CellService and BatchService — both MUST be

package/dist/tools/analysis/check-v12-readiness.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { scanForDeprecatedTi, } from "../../lib/v12-compat/scanner.js";
-import { READ_ONLY, withVersion } from "../annotations.js";
+import { READ_ONLY } from "../annotations.js";
 import { V12ReadinessResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 const RULESET_SOURCE = "vscode-tm1-ti@cf73b93 / tiSignatures.ts (synced 2026-05-12)";
@@ -23,9 +23,9 @@ export const registerCheckV12Readiness = defineTool({
     description: [
         "Static gap-analysis against the TM1 / Planning Analytics v12 (Cloud Native) deprecation list.",
         "Scans every TI process section (prolog/metadata/data/epilog) and every cube rule for functions removed in v12, returning findings with severity, location, and migration hint per occurrence.",
-        "Read-only, two bulk REST calls. Not exhaustive: covers syntactic deprecations only (runtime/semantic differences require manual review).",
+        "Read-only: one bulk request per scope, so two for the default (processes and cube rules) and one when scope names only one of them. Not exhaustive: covers syntactic deprecations only (runtime/semantic differences require manual review).",
     ],
-    annotations: withVersion(READ_ONLY, "v11"),
+    annotations: READ_ONLY,
     output: V12ReadinessResultSchema,
     input: {
         scope: z

package/dist/tools/celldata/check-feeders.js

@@ -1,23 +1,23 @@
 import { z } from "zod";
 import { withToolHint } from "../error-format.js";
 import { CheckFeedersResultSchema } from "../schemas/items.js";
-import { READ_ONLY, withVersion } from "../annotations.js";
+import { READ_ONLY } from "../annotations.js";
 import { defineTool } from "../define-tool.js";
 export const registerCheckFeeders = defineTool({
     name: "tm1_check_feeders",
     description: [
         "Check the feeders of a cell: verifies feeder coverage for the cells underlying this cell and returns the problematic ones with a fed flag — fed=false marks a broken or missing feeder (the classic cause of empty consolidated/rule cells). An empty result means no feeder problems were detected (live-verified on 11.8: fully-fed areas return []).",
         "Per-cell runtime check; complements tm1_audit_feeders (static rule analysis).",
-        "Elements address the default hierarchy, in cube dimension order (discover with tm1_list_cubes).",
-        "v11 only. Related: tm1_trace_feeders (statements involved), tm1_trace_cell_calculation (why has this cell value X).",
+        "Elements are given in cube dimension order (discover with tm1_list_cubes). Write Hierarchy:Element for an alternate hierarchy; the first colon splits, so in dimension Region 'Region:A:B' is element 'A:B' of the default one.",
+        "Related: tm1_trace_feeders (statements involved), tm1_trace_cell_calculation (why has this cell value X).",
     ],
-    annotations: withVersion(READ_ONLY, "v11"),
+    annotations: READ_ONLY,
     output: CheckFeedersResultSchema,
     input: {
         cubeName: z.string().describe("Name of the TM1 cube"),
         elements: z
             .array(z.string())
-            .describe("Element names for each dimension of the cube, in cube dimension order"),
+            .describe("Element names for each dimension of the cube, in cube dimension order. Prefix with a hierarchy to leave the default one: 'AltHier:Elem'."),
         timeoutMs: z
             .number()
             .int()
@@ -30,7 +30,7 @@ export const registerCheckFeeders = defineTool({
         const fedCells = await withToolHint(tm1Client.cells.checkFeeders(cubeName, elements, {
             signal: extra?.signal,
             ...(timeoutMs ? { timeoutMs } : {}),
-        }), `CheckFeeders failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes; alternate hierarchies are not supported. On v12 this action is unavailable.`);
+        }), `CheckFeeders failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes.`);
         return {
             content: [
                 {

package/dist/tools/celldata/check-writable-coords.js

@@ -4,41 +4,48 @@ import { rethrowIfSystemic } from "../../tm1-client/services/fallback.js";
 import { READ_ONLY } from "../annotations.js";
 import { WritableCoordsResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
+import { memberRef } from "./member-ref.js";
 import { dimensionCountMismatch } from "../../lib/coordinate-error.js";
 import { bindLeftOutSandbox, resolveCellAddress, } from "../../lib/cell-address.js";
 export const registerCheckWritableCoords = defineTool({
     name: "tm1_check_writable_coords",
-    description: "Pre-flight check before CellPutN/CellPutS. Verifies (1) every coord element exists, (2) every element is N-Level (writes to Consolidated elements silent-fail), and (3) whether the target cube has rules that may overlap the coord. Returns per-coord status + a rule-overlap warning. Use before writing cells in a TI process or via tm1_write_cells; pass the same dimensions list as the write to check exactly the cell it will address.",
+    description: "Pre-flight check before CellPutN/CellPutS. Verifies (1) every coord element exists, (2) every element is N-Level (whether the server accepts a write to a Consolidated element depends on the account's rights; tm1_write_cells refuses one either way), and (3) whether the target cube has rules that may overlap the coord. Returns per-coord status + a rule-overlap warning. Use before writing cells in a TI process or via tm1_write_cells; pass the same dimensions list as the write to check exactly the cell it will address.",
     annotations: READ_ONLY,
     output: WritableCoordsResultSchema,
     input: {
         cubeName: z.string().describe("Target cube name"),
         coords: z
             .array(z.string())
-            .describe("Element name per dimension: in cube dimension order, or in the order of dimensions when given. Sandboxes may be left out (bound to Base)."),
+            .describe("Element per dimension, in cube dimension order — or in the order of `dimensions` when given. Accepts the same forms as tm1_write_cells: a bare name (default hierarchy) or [Dimension].[Hierarchy].[Element]. Sandboxes may be left out (bound to Base)."),
         dimensions: z
             .array(z.string())
             .optional()
-            .describe("Dimension names for coords, any order — as passed to tm1_write_cells. Every cube dimension except Sandboxes (bound to Base) must be named."),
+            .describe("Optional: the same dimension list tm1_write_cells takes (any order, Sandboxes may be left out and is then bound to Base), so this checks exactly the cell the write will address."),
     },
-    handler: async ({ cubeName, coords: given, dimensions }, tm1Client) => {
-        const cubes = await tm1Client.cubes.list();
-        const cubeMeta = cubes.find((c) => c.name.toLowerCase() === cubeName.toLowerCase());
-        if (!cubeMeta) {
-            throw new TM1Error({
-                code: TM1ErrorCode.NOT_FOUND,
-                message: `Cube '${cubeName}' not found`,
-            });
+    handler: async ({ cubeName, coords: givenCoords, dimensions }, tm1Client) => {
+        // Dimension order only — cached per connection — instead of listing
+        // every cube with its dimensions to find this one.
+        let dims;
+        try {
+            dims = await tm1Client.cubes.getDimensionNames(cubeName);
+        }
+        catch (e) {
+            if (e instanceof TM1Error && e.code === TM1ErrorCode.NOT_FOUND) {
+                throw new TM1Error({
+                    code: TM1ErrorCode.NOT_FOUND,
+                    message: `Cube '${cubeName}' not found`,
+                });
+            }
+            throw e;
         }
-        const dims = cubeMeta.dimensions;
-        let coords = given;
+        let coords = givenCoords;
         let sandboxDefaulted;
         if (dimensions !== undefined) {
-            if (given.length !== dimensions.length) {
-                throw dimensionCountMismatch(cubeName, dimensions, given);
+            if (givenCoords.length !== dimensions.length) {
+                throw dimensionCountMismatch(cubeName, dimensions, givenCoords);
             }
-            const address = resolveCellAddress(cubeName, dims, dimensions);
-            coords = address.toCubeOrder(given);
+            const address = resolveCellAddress(cubeName, dims, dimensions, "Nothing was checked.");
+            coords = address.toCubeOrder(givenCoords);
             sandboxDefaulted = address.sandboxDefaulted;
         }
         else {
@@ -54,9 +61,12 @@ export const registerCheckWritableCoords = defineTool({
         const checks = await Promise.all(dims.map(async (dim, idx) => {
             // coords.length === dims.length is guarded above
             const element = coords[idx];
+            // Same reading of `[Dim].[Hier].[Elem]` as tm1_write_cells, so the
+            // check probes the hierarchy the write would hit. One keyed lookup
+            // per coordinate instead of loading every hierarchy of the cube.
+            const ref = memberRef(dim, element);
             try {
-                const hier = await tm1Client.hierarchies.get(dim, dim);
-                const el = hier.elements.find((e) => e.name.toLowerCase() === element.toLowerCase());
+                const el = await tm1Client.elements.getType(ref.dimension, ref.hierarchy, ref.element);
                 if (!el) {
                     return {
                         dimension: dim,
@@ -66,12 +76,13 @@ export const registerCheckWritableCoords = defineTool({
                         isNLevel: false,
                     };
                 }
+                const type = el.type;
                 return {
                     dimension: dim,
-                    element: el.name,
+                    element: element === ref.element ? el.name : element,
                     exists: true,
-                    type: el.type,
-                    isNLevel: el.type !== "Consolidated",
+                    type,
+                    isNLevel: type !== "Consolidated",
                 };
             }
             catch (e) {

package/dist/tools/celldata/execute-mdx.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { PAGINATION_SCHEMA } from "../pagination.js";
+import { PAGINATION_SCHEMA, UNBOUNDED_MAX_ITEMS } from "../pagination.js";
 import { FORMAT_SCHEMA, mdEscape, payloadResponse } from "../format.js";
 import { withToolHint } from "../error-format.js";
 import { clipAxesToWindow } from "../../tm1-client/services/cellset-transform.js";
@@ -71,7 +71,7 @@ export const registerExecuteMdx = defineTool({
     name: "tm1_execute_mdx",
     description: [
         "Execute an MDX query against the TM1 server and return structured cell data with axes (page-envelope shape consistent with list_*).",
-        "format='markdown' renders a pivot grid (2 axes, full result — set fetchAll=true to avoid a partial grid) or a flat coordinate table; 'json' (default) returns the structured envelope.",
+        "format='markdown' renders a pivot grid (2 axes; set fetchAll=true to get up to 5000 cells in one grid) or a flat coordinate table; 'json' (default) returns the structured envelope.",
         "Related: tm1_create_mdx_view to persist a query as a public view, tm1_sample_cells for cheap sparsity probe, tm1_get_cell_value for a single coordinate.",
     ],
     annotations: READ_ONLY,
@@ -90,8 +90,11 @@ export const registerExecuteMdx = defineTool({
     },
     handler: async ({ mdx, limit, offset, fetchAll, format, timeoutMs }, tm1Client, extra) => {
         const all = fetchAll === true || limit === 0;
-        const top = all ? undefined : limit;
-        const skip = all ? undefined : offset;
+        // "All" is the documented first slab of UNBOUNDED_MAX_ITEMS, pushed down
+        // to TM1 as $top — not the whole cellset. has_more/next_offset then say
+        // where to resume, exactly as for any other page.
+        const top = all ? UNBOUNDED_MAX_ITEMS : limit;
+        const skip = all ? 0 : offset;
         const result = await withToolHint(tm1Client.cells.executeMdx(mdx, top, skip, {
             signal: extra?.signal,
             ...(timeoutMs ? { timeoutMs } : {}),
@@ -99,12 +102,10 @@ export const registerExecuteMdx = defineTool({
         const total = result.totalCellCount;
         const count = result.cells.length;
         const off = all ? 0 : offset;
-        const has_more = !all && off + count < total;
+        const has_more = off + count < total;
         // Clip axes to the returned cell page so a capped read over a huge view
-        // doesn't ship the full tuple list. fetchAll keeps the whole cellset.
-        const { axes, clipped } = all
-            ? { axes: result.axes, clipped: false }
-            : clipAxesToWindow(result.axes, count, off);
+        // doesn't ship the full tuple list.
+        const { axes, clipped } = clipAxesToWindow(result.axes, count, off);
         const envelope = {
             axes,
             total,

package/dist/tools/celldata/get-view.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { PAGINATION_SCHEMA } from "../pagination.js";
+import { PAGINATION_SCHEMA, UNBOUNDED_MAX_ITEMS } from "../pagination.js";
 import { FORMAT_SCHEMA, payloadResponse } from "../format.js";
 import { renderMdxMarkdown } from "./execute-mdx.js";
 import { clipAxesToWindow } from "../../tm1-client/services/cellset-transform.js";
@@ -10,7 +10,7 @@ export const registerGetView = defineTool({
     name: "tm1_get_view",
     description: [
         "Execute a named cube view and return structured cell data with axes (page-envelope shape consistent with tm1_execute_mdx).",
-        "Cells paginate by default so wide/tall views don't flood context; fetchAll=true for the full cellset.",
+        "Cells paginate by default so wide/tall views don't flood context; fetchAll=true returns up to 5000 cells in one call; has_more/next_offset tell where to resume.",
         "format='markdown' renders a pivot grid (2 axes, full result) or a flat coordinate table; 'json' (default) returns the structured envelope.",
     ],
     annotations: READ_ONLY,
@@ -23,20 +23,21 @@ export const registerGetView = defineTool({
     },
     handler: async ({ cubeName, viewName, limit, offset, fetchAll, format }, tm1Client, extra) => {
         const all = fetchAll === true || limit === 0;
-        const top = all ? undefined : limit;
-        const skip = all ? undefined : offset;
+        // "All" is the documented first slab of UNBOUNDED_MAX_ITEMS, pushed down
+        // to TM1 as $top — not the whole cellset. has_more/next_offset then say
+        // where to resume, exactly as for any other page.
+        const top = all ? UNBOUNDED_MAX_ITEMS : limit;
+        const skip = all ? 0 : offset;
         const result = await tm1Client.views.getView(cubeName, viewName, top, skip, {
             signal: extra?.signal,
         });
         const total = result.totalCellCount;
         const count = result.cells.length;
         const off = all ? 0 : offset;
-        const has_more = !all && off + count < total;
+        const has_more = off + count < total;
         // Clip axes to the returned cell page so a capped read over a tall view
-        // doesn't ship the full tuple list. fetchAll keeps the whole cellset.
-        const { axes, clipped } = all
-            ? { axes: result.axes, clipped: false }
-            : clipAxesToWindow(result.axes, count, off);
+        // doesn't ship the full tuple list.
+        const { axes, clipped } = clipAxesToWindow(result.axes, count, off);
         const envelope = {
             cubeName,
             viewName,

package/dist/tools/celldata/member-ref.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Where an element reference points, in the four shapes cell-service's
+ * `qualifyWriteMember` accepts: a bare name, `[Element]`,
+ * `[Dimension].[Element]` (default hierarchy) and the fully qualified
+ * `[Dimension].[Hierarchy].[Element]`.
+ *
+ * Both sides must read a reference the same way. Where this function and the
+ * writer disagree, the guard probes one coordinate and the write hits another.
+ */
+export declare function memberRef(dimension: string, element: string): {
+    dimension: string;
+    hierarchy: string;
+    element: string;
+};
+//# sourceMappingURL=member-ref.d.ts.map

package/dist/tools/celldata/member-ref.js

@@ -0,0 +1,67 @@
+/**
+ * Split a bracketed MDX reference into its parts, `]]` unescaped back to `]`.
+ *
+ * Hand-parsed rather than matched: a regex over `[^\]]+` cannot see past an
+ * escaped `]]`, so every name containing a `]` would fall out of the guard
+ * and be written unchecked.
+ *
+ * Returns null for anything that is not a well-formed bracketed reference —
+ * the caller then treats the string as a bare element name, which is what the
+ * writer does with it too.
+ */
+function mdxParts(ref) {
+    const parts = [];
+    let i = 0;
+    while (i < ref.length) {
+        if (ref[i] !== "[")
+            return null;
+        i++;
+        let name = "";
+        for (;;) {
+            if (i >= ref.length)
+                return null;
+            if (ref[i] === "]") {
+                if (ref[i + 1] === "]") {
+                    name += "]";
+                    i += 2;
+                    continue;
+                }
+                i++;
+                break;
+            }
+            name += ref[i];
+            i++;
+        }
+        parts.push(name);
+        if (i === ref.length)
+            return parts;
+        if (ref[i] !== ".")
+            return null;
+        i++;
+    }
+    return null;
+}
+/**
+ * Where an element reference points, in the four shapes cell-service's
+ * `qualifyWriteMember` accepts: a bare name, `[Element]`,
+ * `[Dimension].[Element]` (default hierarchy) and the fully qualified
+ * `[Dimension].[Hierarchy].[Element]`.
+ *
+ * Both sides must read a reference the same way. Where this function and the
+ * writer disagree, the guard probes one coordinate and the write hits another.
+ */
+export function memberRef(dimension, element) {
+    const parts = element.startsWith("[") ? mdxParts(element) : null;
+    if (parts?.length === 3) {
+        return { dimension: parts[0], hierarchy: parts[1], element: parts[2] };
+    }
+    if (parts?.length === 2) {
+        return { dimension: parts[0], hierarchy: parts[0], element: parts[1] };
+    }
+    return {
+        dimension,
+        hierarchy: dimension,
+        element: parts?.length === 1 ? parts[0] : element,
+    };
+}
+//# sourceMappingURL=member-ref.js.map

package/dist/tools/celldata/trace-cell-calculation.js

@@ -1,23 +1,23 @@
 import { z } from "zod";
 import { withToolHint } from "../error-format.js";
 import { CalculationTraceResultSchema } from "../schemas/items.js";
-import { READ_ONLY, withVersion } from "../annotations.js";
+import { READ_ONLY } from "../annotations.js";
 import { defineTool } from "../define-tool.js";
 export const registerTraceCellCalculation = defineTool({
     name: "tm1_trace_cell_calculation",
     description: [
         "Trace how a cell value is calculated: recursive component tree with per-component type (Consolidation/Rule/Simple), status (Null/Data/Error), value, and the rule statements that populate it — answers 'why is this cell X / empty?'.",
         "The tree is truncated client-side via maxDepth/maxComponents; truncated=true marks cut branches (re-run with the branch tuple as new start cell to drill deeper).",
-        "Elements address the default hierarchy, in cube dimension order (discover with tm1_list_cubes).",
-        "v11 only. Related: tm1_check_feeders / tm1_trace_feeders for feeder issues, tm1_get_cube_rules for the full rule text.",
+        "Elements are given in cube dimension order (discover with tm1_list_cubes). Write Hierarchy:Element for an alternate hierarchy; the first colon splits, so in dimension Region 'Region:A:B' is element 'A:B' of the default one.",
+        "Related: tm1_check_feeders / tm1_trace_feeders for feeder issues, tm1_get_cube_rules for the full rule text.",
     ],
-    annotations: withVersion(READ_ONLY, "v11"),
+    annotations: READ_ONLY,
     output: CalculationTraceResultSchema,
     input: {
         cubeName: z.string().describe("Name of the TM1 cube"),
         elements: z
             .array(z.string())
-            .describe("Element names for each dimension of the cube, in cube dimension order"),
+            .describe("Element names for each dimension of the cube, in cube dimension order. Prefix with a hierarchy to leave the default one: 'AltHier:Elem'."),
         maxDepth: z
             .number()
             .int()
@@ -44,7 +44,7 @@ export const registerTraceCellCalculation = defineTool({
         const tree = await withToolHint(tm1Client.cells.traceCellCalculation(cubeName, elements, maxDepth, maxComponents, {
             signal: extra?.signal,
             ...(timeoutMs ? { timeoutMs } : {}),
-        }), `TraceCellCalculation failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes; alternate hierarchies are not supported. On v12 this action is unavailable.`);
+        }), `TraceCellCalculation failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes.`);
         return {
             content: [{ type: "text", text: JSON.stringify(tree) }],
         };

package/dist/tools/celldata/trace-feeders.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { withToolHint } from "../error-format.js";
-import { READ_ONLY, withVersion } from "../annotations.js";
+import { READ_ONLY } from "../annotations.js";
 import { TraceFeedersResultSchema } from "../schemas/items.js";
 import { defineTool } from "../define-tool.js";
 export const registerTraceFeeders = defineTool({
@@ -8,16 +8,16 @@ export const registerTraceFeeders = defineTool({
     description: [
         "Trace the feeders of a cell: returns the cells this cell feeds plus the feeder statements involved — answers 'which feeder statement fires from this cell, and where to'.",
         "Use when a rule cell stays empty under SKIPCHECK: trace the source cell to see whether its feeder reaches the target.",
-        "Elements address the default hierarchy, in cube dimension order (discover with tm1_list_cubes).",
-        "v11 only. Related: tm1_check_feeders (fed/unfed flags), tm1_audit_feeders (static analysis).",
+        "Elements are given in cube dimension order (discover with tm1_list_cubes). Write Hierarchy:Element for an alternate hierarchy; the first colon splits, so in dimension Region 'Region:A:B' is element 'A:B' of the default one.",
+        "Related: tm1_check_feeders (fed/unfed flags), tm1_audit_feeders (static analysis).",
     ],
-    annotations: withVersion(READ_ONLY, "v11"),
+    annotations: READ_ONLY,
     output: TraceFeedersResultSchema,
     input: {
         cubeName: z.string().describe("Name of the TM1 cube"),
         elements: z
             .array(z.string())
-            .describe("Element names for each dimension of the cube, in cube dimension order"),
+            .describe("Element names for each dimension of the cube, in cube dimension order. Prefix with a hierarchy to leave the default one: 'AltHier:Elem'."),
         timeoutMs: z
             .number()
             .int()
@@ -30,7 +30,7 @@ export const registerTraceFeeders = defineTool({
         const result = await withToolHint(tm1Client.cells.traceFeeders(cubeName, elements, {
             signal: extra?.signal,
             ...(timeoutMs ? { timeoutMs } : {}),
-        }), `TraceFeeders failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes; alternate hierarchies are not supported. On v12 this action is unavailable.`);
+        }), `TraceFeeders failed for cube '${cubeName}'. Verify dimension order/elements via tm1_list_cubes.`);
         return {
             content: [
                 {