@ffschrattenecker/tm1-mcp-server 7.0.2 → 8.1.0

package/dist/tm1-client/services/cell-service.d.ts

@@ -1,8 +1,10 @@
 import type { CalculationTraceNode, CellValue, FedCellDescriptor, FeederTraceResult, MdxResult } from "../../types.js";
 import type { RequestOptions, TM1HttpClient } from "../http.js";
+import { DimensionOrderCache } from "./dimension-order.js";
 export declare class CellService {
     private readonly http;
-    constructor(http: TM1HttpClient);
+    private readonly dimOrder;
+    constructor(http: TM1HttpClient, dimOrder?: DimensionOrderCache);
     /**
      * Get a single cell value via a 1-tuple MDX query.
      *
@@ -42,20 +44,20 @@ export declare class CellService {
     }>): Promise<void>;
     /**
      * Resolve the cube's dimension order and build Tuple@odata.bind paths for
-     * the cell-bound trace actions. Elements address the default hierarchy
-     * (same name as the dimension) — alternate hierarchies are not supported
-     * by these diagnostics tools.
+     * the cell-bound trace actions. Each entry addresses the dimension's default
+     * hierarchy, or an alternate one when written `Hier:Elem` — see
+     * splitHierarchyQualified().
      */
     private tupleBinds;
     /**
      * Check the feeders of a cell: returns the cells fed by this cell with a
-     * Fed flag per target — Fed=false marks a broken/missing feeder. v11 only.
+     * Fed flag per target — Fed=false marks a broken/missing feeder.
      * POST /api/v1/Cubes('{cube}')/tm1.CheckFeeders
      */
     checkFeeders(cubeName: string, elements: string[], opts?: RequestOptions): Promise<FedCellDescriptor[]>;
     /**
      * Trace the feeders of a cell: returns the cells this cell feeds plus the
-     * feeder statements involved. v11 only.
+     * feeder statements involved.
      * POST /api/v1/Cubes('{cube}')/tm1.TraceFeeders
      */
     traceFeeders(cubeName: string, elements: string[], opts?: RequestOptions): Promise<FeederTraceResult>;
@@ -63,7 +65,7 @@ export declare class CellService {
      * Trace how a cell value is calculated: recursive component tree with
      * per-component type (consolidation/rule), status, value, and rule
      * statements. The server returns the full tree; maxDepth/maxComponents
-     * truncate client-side to keep responses bounded. v11 only.
+     * truncate client-side to keep responses bounded.
      * POST /api/v1/Cubes('{cube}')/tm1.TraceCellCalculation
      */
     traceCellCalculation(cubeName: string, elements: string[], maxDepth?: number, maxComponents?: number, opts?: RequestOptions): Promise<CalculationTraceNode>;

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

@@ -1,16 +1,38 @@
 // Cell domain service. Owns single-cell reads, MDX cellset execution, and
 // cell writes via the cellset PATCH path. Cube-shape lookups (resolving
-// dimension order for getValue) go through the request layer directly rather
-// than CubeService to avoid a CubeService → CellService cycle later.
+// dimension order for getValue) go through the shared DimensionOrderCache
+// rather than CubeService to avoid a CubeService → CellService cycle later.
 //
 // See docs/ARCHITECTURE.md for the layering.
 import { TM1Error, TM1ErrorCode } from "../../types.js";
 import { escapeMdxName } from "../../lib/mdx.js";
 import { dimensionCountMismatch } from "../../lib/coordinate-error.js";
 import { bindLeftOutSandbox } from "../../lib/cell-address.js";
+import { mapSettledWithConcurrency } from "../../lib/concurrency.js";
 import { freeCellset, transformCellsetResponse } from "./cellset-transform.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";
+import { DimensionOrderCache } from "./dimension-order.js";
+// In-flight cap for the per-cell re-walk after a refused bulk write.
+const FALLBACK_CONCURRENCY = 8;
+/**
+ * Split one entry of a cell coordinate into (hierarchy, element).
+ *
+ * A bare name addresses the dimension's DEFAULT hierarchy, which carries the
+ * dimension's own name. `Hier:Elem` addresses an alternate hierarchy — the
+ * same `Dim:Hier` idiom TM1 rules use, one slot down.
+ *
+ * The split takes the FIRST colon, and the dimension's default hierarchy can
+ * always be named explicitly, so an element whose own name contains a colon
+ * stays reachable: in dimension `Region`, `Region:A:B` is element `A:B` in
+ * the default hierarchy. A leading or trailing colon cannot separate anything,
+ * so such an entry is taken as a plain element name.
+ */
+function splitHierarchyQualified(entry, dimension) {
+    const i = entry.indexOf(":");
+    if (i <= 0 || i === entry.length - 1)
+        return { hierarchy: dimension, element: entry };
+    return { hierarchy: entry.slice(0, i), element: entry.slice(i + 1) };
+}
 // Build a fully-qualified MDX member reference for a write coordinate.
 // A caller may pass a pre-qualified ref to target an ALTERNATE hierarchy
 // (`[Dim].[AltHier].[Elem]`, or `[Dim].[Elem]` for the default) — passed
@@ -27,8 +49,10 @@ function qualifyWriteMember(dim, element) {
 }
 export class CellService {
     http;
-    constructor(http) {
+    dimOrder;
+    constructor(http, dimOrder = new DimensionOrderCache(http)) {
         this.http = http;
+        this.dimOrder = dimOrder;
     }
     /**
      * Get a single cell value via a 1-tuple MDX query.
@@ -42,9 +66,7 @@ export class CellService {
         if (elements.length === 0) {
             return null;
         }
-        const cubePath = `/api/v1/Cubes('${enc(cubeName)}')?$expand=Dimensions($select=Name)`;
-        const cubeMeta = await this.http.request("GET", cubePath);
-        const dims = cubeMeta.Dimensions.map((d) => d.Name);
+        const dims = await this.dimOrder.get(cubeName);
         // Sandboxes left out → Base, as tm1_write_cells does.
         elements = bindLeftOutSandbox(dims, elements) ?? elements;
         if (elements.length !== dims.length) {
@@ -164,11 +186,11 @@ export class CellService {
             const cellset = await this.http.request("POST", "/api/v1/ExecuteMDX", { MDX: mdx });
             const id = cellset.ID;
             try {
-                await this.http.request("PATCH", `/api/v1/Cellsets('${enc(id)}')/Cells(0)`, { Value: c.value });
+                await this.http.request("PATCH", `/api/v1/Cellsets('${odataKey(id)}')/Cells(0)`, { Value: c.value });
             }
             finally {
                 try {
-                    await this.http.request("DELETE", `/api/v1/Cellsets('${enc(id)}')`);
+                    await this.http.request("DELETE", `/api/v1/Cellsets('${odataKey(id)}')`);
                 }
                 catch {
                     // cleanup best-effort
@@ -186,7 +208,7 @@ export class CellService {
             let bulkFailed = false;
             const cellset = await this.http.request("POST", "/api/v1/ExecuteMDX", { MDX: mdx });
             try {
-                await this.http.request("PATCH", `/api/v1/Cellsets('${enc(cellset.ID)}')/Cells`, chunk.map((c, ordinal) => ({ Ordinal: ordinal, Value: c.value })));
+                await this.http.request("PATCH", `/api/v1/Cellsets('${odataKey(cellset.ID)}')/Cells`, chunk.map((c, ordinal) => ({ Ordinal: ordinal, Value: c.value })));
                 written += chunk.length;
             }
             catch {
@@ -200,7 +222,7 @@ export class CellService {
             }
             finally {
                 try {
-                    await this.http.request("DELETE", `/api/v1/Cellsets('${enc(cellset.ID)}')`);
+                    await this.http.request("DELETE", `/api/v1/Cellsets('${odataKey(cellset.ID)}')`);
                 }
                 catch {
                     // cleanup best-effort
@@ -208,7 +230,9 @@ export class CellService {
             }
             if (!bulkFailed)
                 continue;
-            const results = await Promise.allSettled(chunk.map(writeOne));
+            // Bounded: re-walking a 500-cell chunk unbounded put ~1500 requests
+            // (cellset, PATCH, delete per cell) in flight against the worker pool.
+            const results = await mapSettledWithConcurrency(chunk, FALLBACK_CONCURRENCY, (c) => writeOne(c));
             const failed = [];
             results.forEach((r, j) => {
                 if (r.status === "fulfilled") {
@@ -238,39 +262,41 @@ export class CellService {
     }
     /**
      * Resolve the cube's dimension order and build Tuple@odata.bind paths for
-     * the cell-bound trace actions. Elements address the default hierarchy
-     * (same name as the dimension) — alternate hierarchies are not supported
-     * by these diagnostics tools.
+     * the cell-bound trace actions. Each entry addresses the dimension's default
+     * hierarchy, or an alternate one when written `Hier:Elem` — see
+     * splitHierarchyQualified().
      */
     async tupleBinds(cubeName, elements) {
-        const cubeMeta = await this.http.request("GET", `/api/v1/Cubes('${enc(cubeName)}')?$expand=Dimensions($select=Name)`);
-        const dims = cubeMeta.Dimensions.map((d) => d.Name);
+        const dims = await this.dimOrder.get(cubeName);
         if (elements.length !== dims.length) {
             throw new TM1Error({
                 code: TM1ErrorCode.VALIDATION_ERROR,
                 message: `Cube '${cubeName}' has ${dims.length} dimension(s) (${dims.join(", ")}) but ${elements.length} element(s) were given`,
             });
         }
-        return dims.map((d, i) => `Dimensions('${enc(d)}')/Hierarchies('${enc(d)}')/Elements('${enc(elements[i])}')`);
+        return dims.map((d, i) => {
+            const { hierarchy, element } = splitHierarchyQualified(elements[i], d);
+            return `Dimensions('${odataKey(d)}')/Hierarchies('${odataKey(hierarchy)}')/Elements('${odataKey(element)}')`;
+        });
     }
     /**
      * Check the feeders of a cell: returns the cells fed by this cell with a
-     * Fed flag per target — Fed=false marks a broken/missing feeder. v11 only.
+     * Fed flag per target — Fed=false marks a broken/missing feeder.
      * POST /api/v1/Cubes('{cube}')/tm1.CheckFeeders
      */
     async checkFeeders(cubeName, elements, opts) {
         const binds = await this.tupleBinds(cubeName, elements);
-        const response = await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/tm1.CheckFeeders?$expand=Cube($select=Name),Tuple($select=Name)`, { "Tuple@odata.bind": binds }, opts);
+        const response = await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/tm1.CheckFeeders?$expand=Cube($select=Name),Tuple($select=Name)`, { "Tuple@odata.bind": binds }, opts);
         return (response.value ?? []).map(mapFedCell);
     }
     /**
      * Trace the feeders of a cell: returns the cells this cell feeds plus the
-     * feeder statements involved. v11 only.
+     * feeder statements involved.
      * POST /api/v1/Cubes('{cube}')/tm1.TraceFeeders
      */
     async traceFeeders(cubeName, elements, opts) {
         const binds = await this.tupleBinds(cubeName, elements);
-        const response = await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/tm1.TraceFeeders?$expand=FedCells/Cube($select=Name),FedCells/Tuple($select=Name)`, { "Tuple@odata.bind": binds }, opts);
+        const response = await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/tm1.TraceFeeders?$expand=FedCells/Cube($select=Name),FedCells/Tuple($select=Name)`, { "Tuple@odata.bind": binds }, opts);
         return {
             fedCells: (response.FedCells ?? []).map(mapFedCell),
             statements: response.Statements ?? [],
@@ -280,7 +306,7 @@ export class CellService {
      * Trace how a cell value is calculated: recursive component tree with
      * per-component type (consolidation/rule), status, value, and rule
      * statements. The server returns the full tree; maxDepth/maxComponents
-     * truncate client-side to keep responses bounded. v11 only.
+     * truncate client-side to keep responses bounded.
      * POST /api/v1/Cubes('{cube}')/tm1.TraceCellCalculation
      */
     async traceCellCalculation(cubeName, elements, maxDepth = 3, maxComponents = 20, opts) {
@@ -296,7 +322,7 @@ export class CellService {
             const prefix = "Components/".repeat(level);
             expandParts.push(`${prefix}Tuple($select=Name)`, `${prefix}Cube($select=Name)`);
         }
-        const response = await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/tm1.TraceCellCalculation?$expand=${expandParts.join(",")}`, { "Tuple@odata.bind": binds }, opts);
+        const response = await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/tm1.TraceCellCalculation?$expand=${expandParts.join(",")}`, { "Tuple@odata.bind": binds }, opts);
         return mapCalcComponent(response, maxDepth, maxComponents);
     }
 }

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

@@ -5,8 +5,7 @@
 import { CHORE_STATUS_UNAVAILABLE, TM1Error, TM1ErrorCode, } from "../../types.js";
 import { classifyChoreExecution } from "./chore-status.js";
 import { rethrowIfSystemic } 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";
 function frequencyDuration(f) {
     return `P${f.days}DT${String(f.hours).padStart(2, "0")}H${String(f.minutes).padStart(2, "0")}M${String(f.seconds).padStart(2, "0")}S`;
 }
@@ -45,7 +44,7 @@ export class ChoreService {
      * PATCH /api/v1/Chores('{name}') with { Active: bool }
      */
     async toggleActive(choreName, active) {
-        const path = `/api/v1/Chores('${enc(choreName)}')`;
+        const path = `/api/v1/Chores('${odataKey(choreName)}')`;
         await this.http.request("PATCH", path, { Active: active });
     }
     /**
@@ -65,11 +64,11 @@ export class ChoreService {
      *   — everywhere else. Returns 204, so no status exists to report.
      */
     async execute(choreName, opts) {
-        const plain = `/api/v1/Chores('${enc(choreName)}')/tm1.Execute`;
+        const plain = `/api/v1/Chores('${odataKey(choreName)}')/tm1.Execute`;
         if (this.withReturnSupported === false) {
             return this.executeWithoutStatus(plain, opts);
         }
-        const withReturn = `/api/v1/Chores('${enc(choreName)}')/tm1.ExecuteWithReturn?$expand=ErrorLogFile`;
+        const withReturn = `/api/v1/Chores('${odataKey(choreName)}')/tm1.ExecuteWithReturn?$expand=ErrorLogFile`;
         try {
             const response = await this.http.request("POST", withReturn, {}, opts);
             this.withReturnSupported = true;
@@ -129,7 +128,7 @@ export class ChoreService {
             Frequency: frequencyDuration(chore.frequency),
             Tasks: chore.steps.map((step, idx) => ({
                 Step: idx,
-                "Process@odata.bind": `Processes('${enc(step.process)}')`,
+                "Process@odata.bind": `Processes('${odataKey(step.process)}')`,
                 Parameters: step.parameters.map((p) => ({
                     Name: p.name,
                     Value: p.value,
@@ -143,7 +142,7 @@ export class ChoreService {
      * PATCH /api/v1/Chores('{name}')
      */
     async update(choreName, updates) {
-        const path = `/api/v1/Chores('${enc(choreName)}')`;
+        const path = `/api/v1/Chores('${odataKey(choreName)}')`;
         const body = {};
         if (updates.startTime !== undefined)
             body.StartTime = updates.startTime;
@@ -159,7 +158,7 @@ export class ChoreService {
         if (updates.steps !== undefined) {
             body.Tasks = updates.steps.map((step, idx) => ({
                 Step: idx,
-                "Process@odata.bind": `Processes('${enc(step.process)}')`,
+                "Process@odata.bind": `Processes('${odataKey(step.process)}')`,
                 Parameters: step.parameters.map((p) => ({
                     Name: p.name,
                     Value: p.value,
@@ -173,7 +172,7 @@ export class ChoreService {
      * DELETE /api/v1/Chores('{name}')
      */
     async delete(choreName) {
-        await this.http.request("DELETE", `/api/v1/Chores('${enc(choreName)}')`);
+        await this.http.request("DELETE", `/api/v1/Chores('${odataKey(choreName)}')`);
     }
 }
 //# sourceMappingURL=chore-service.js.map

package/dist/tm1-client/services/cube-service.d.ts

@@ -1,6 +1,7 @@
 import type { Cube, CubeRules, RuleSyntaxError } from "../../types.js";
-import type { TM1HttpClient } from "../http.js";
+import type { RequestOptions, TM1HttpClient } from "../http.js";
 import { type NameFilterOpts, type Paged, type PageOpts } from "./odata-page.js";
+import { DimensionOrderCache } from "./dimension-order.js";
 export interface AllRulesOpts {
     /** Include control cubes (`}`-prefixed). Default false. */
     includeControl?: boolean;
@@ -14,7 +15,8 @@ export interface CubeListOpts extends NameFilterOpts {
 }
 export declare class CubeService {
     private readonly http;
-    constructor(http: TM1HttpClient);
+    private readonly dimOrder;
+    constructor(http: TM1HttpClient, dimOrder?: DimensionOrderCache);
     /**
      * List all cubes with their dimension names.
      * GET /api/v1/Cubes?$expand=Dimensions($select=Name)
@@ -36,7 +38,8 @@ export declare class CubeService {
         page: PageOpts;
     }): Promise<Paged<Cube>>;
     /**
-     * Return ordered dimension-name list of a cube.
+     * Return ordered dimension-name list of a cube. Cached per connection —
+     * see dimension-order.ts.
      * GET /api/v1/Cubes('{name}')?$expand=Dimensions($select=Name)
      */
     getDimensionNames(cubeName: string): Promise<string[]>;
@@ -104,23 +107,16 @@ export declare class CubeService {
      */
     checkRule(cubeName: string, ruleText: string): Promise<RuleSyntaxError[]>;
     /**
-     * Clear cube cells.
+     * Clear every cell in a cube.
      *
-     * A **full** clear runs an ephemeral TI with CubeClearData(). tm1.Clear is
-     * not an alternative on either build: 11.8 and 12.5 both answer
-     * "'tm1.Clear' resource can not be resolved on type 'Cube'" for a cube that
-     * exists, and neither declares a clear action anywhere in $metadata — Cube
-     * carries only Lock and Unlock. CubeClearData() is the only route measured
-     * to work.
-     *
-     * A **partial** clear would need tuple selectors, which only tm1.Clear
-     * offers, so no server reachable here can do one. Callers get
-     * UNSUPPORTED_OPERATION pointing at bedrock `}bedrock.cube.data.clear`
-     * rather than a request that is known to 404.
+     * The clear runs an ephemeral TI with CubeClearData(). tm1.Clear is not an
+     * alternative on either build: 11.8 and 12.5 both answer "'tm1.Clear'
+     * resource can not be resolved on type 'Cube'" for a cube that exists, and
+     * neither declares a clear action anywhere in $metadata — Cube carries only
+     * Lock and Unlock. CubeClearData() is the only route measured to work, and
+     * it takes a cube name and nothing else, so there is no region to scope.
      */
-    clear(cubeName: string, dimensions: string[], tuples: string[][]): Promise<void>;
-    /** Same verdict for both versions: no tuple-selective clear on this server. */
-    private partialClearUnsupported;
+    clear(cubeName: string, opts?: Pick<RequestOptions, "timeoutMs">): Promise<void>;
     /**
      * Unload a cube from memory. Forces TM1 to discard the in-memory fed-cell
      * index and reload from disk on next access. Required for feeder corrections

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

@@ -5,14 +5,15 @@
 // as deprecated wrappers during the migration period (Phase 1 of the
 // god-class split — see docs/ARCHITECTURE.md).
 import { TM1Error, TM1ErrorCode } from "../../types.js";
-import { filterClause, nameFilterPredicates, pageClauses, readCount, } from "./odata-page.js";
+import { filterClause, nameFilterPredicates, pageClauses, readCount, odataKey, } from "./odata-page.js";
 import { classifyExecution } from "./process-status.js";
-// OData key encoder: double ' per OData literal rules, then percent-encode.
-const enc = (s) => encodeURIComponent(String(s).replace(/'/g, "''"));
+import { DimensionOrderCache } from "./dimension-order.js";
 export class CubeService {
     http;
-    constructor(http) {
+    dimOrder;
+    constructor(http, dimOrder = new DimensionOrderCache(http)) {
         this.http = http;
+        this.dimOrder = dimOrder;
     }
     async list(opts = {}) {
         // Without a top-level $select TM1 returns every cube property — including
@@ -41,13 +42,12 @@ export class CubeService {
             : { items, total: readCount(response) };
     }
     /**
-     * Return ordered dimension-name list of a cube.
+     * Return ordered dimension-name list of a cube. Cached per connection —
+     * see dimension-order.ts.
      * GET /api/v1/Cubes('{name}')?$expand=Dimensions($select=Name)
      */
     async getDimensionNames(cubeName) {
-        const path = `/api/v1/Cubes('${enc(cubeName)}')?$expand=Dimensions($select=Name)`;
-        const response = await this.http.request("GET", path);
-        return response.Dimensions.map((d) => d.Name);
+        return this.dimOrder.get(cubeName);
     }
     /**
      * Cheap existence probe: a single GET with $select=Name (404 → false)
@@ -62,7 +62,7 @@ export class CubeService {
      */
     async exists(cubeName) {
         try {
-            await this.http.request("GET", `/api/v1/Cubes('${enc(cubeName)}')?$select=Name`);
+            await this.http.request("GET", `/api/v1/Cubes('${odataKey(cubeName)}')?$select=Name`);
             return true;
         }
         catch (e) {
@@ -79,7 +79,7 @@ export class CubeService {
         await this.http.request("POST", "/api/v1/Cubes", {
             Name: name,
             Dimensions: dimensionNames.map((d) => ({
-                "@odata.id": `Dimensions('${enc(d)}')`,
+                "@odata.id": `Dimensions('${odataKey(d)}')`,
             })),
         });
     }
@@ -88,21 +88,21 @@ export class CubeService {
      * DELETE /api/v1/Cubes('{name}')
      */
     async delete(name) {
-        await this.http.request("DELETE", `/api/v1/Cubes('${enc(name)}')`);
+        await this.http.request("DELETE", `/api/v1/Cubes('${odataKey(name)}')`);
     }
     /**
      * Get the rules text for a cube.
      * GET /api/v1/Cubes('{name}')/Rules
      */
     async getRules(cubeName) {
-        const path = `/api/v1/Cubes('${enc(cubeName)}')/Rules`;
+        const path = `/api/v1/Cubes('${odataKey(cubeName)}')/Rules`;
         // TM1 returns 404/204 both for "cube missing" and "cube has no rules";
         // an empty 200 body (response undefined) also means "no rules". For any
         // of those, probe `/Cubes('X')?$select=Name` to disambiguate so callers
         // get a clear NOT_FOUND for typos instead of a silently-empty rulesText.
         const empty = async () => {
             try {
-                await this.http.request("GET", `/api/v1/Cubes('${enc(cubeName)}')?$select=Name`);
+                await this.http.request("GET", `/api/v1/Cubes('${odataKey(cubeName)}')?$select=Name`);
             }
             catch (probeErr) {
                 if (probeErr instanceof TM1Error && probeErr.httpStatus === 404) {
@@ -173,7 +173,7 @@ export class CubeService {
      * text, so it travels in `rulesText` like every other statement.
      */
     async updateRules(cubeName, rulesText) {
-        const cubePath = `/api/v1/Cubes('${enc(cubeName)}')`;
+        const cubePath = `/api/v1/Cubes('${odataKey(cubeName)}')`;
         await this.http.request("PATCH", cubePath, { Rules: rulesText });
     }
     /**
@@ -181,7 +181,7 @@ export class CubeService {
      * POST /api/v1/Cubes('{name}')/tm1.CheckRules with { Rules: "..." }
      */
     async checkRule(cubeName, ruleText) {
-        const path = `/api/v1/Cubes('${enc(cubeName)}')/tm1.CheckRules`;
+        const path = `/api/v1/Cubes('${odataKey(cubeName)}')/tm1.CheckRules`;
         const response = await this.http.request("POST", path, { Rules: ruleText });
         return (response.value ?? []).map((e) => ({
             message: e.Message,
@@ -189,33 +189,17 @@ export class CubeService {
         }));
     }
     /**
-     * Clear cube cells.
-     *
-     * A **full** clear runs an ephemeral TI with CubeClearData(). tm1.Clear is
-     * not an alternative on either build: 11.8 and 12.5 both answer
-     * "'tm1.Clear' resource can not be resolved on type 'Cube'" for a cube that
-     * exists, and neither declares a clear action anywhere in $metadata — Cube
-     * carries only Lock and Unlock. CubeClearData() is the only route measured
-     * to work.
+     * Clear every cell in a cube.
      *
-     * A **partial** clear would need tuple selectors, which only tm1.Clear
-     * offers, so no server reachable here can do one. Callers get
-     * UNSUPPORTED_OPERATION pointing at bedrock `}bedrock.cube.data.clear`
-     * rather than a request that is known to 404.
+     * The clear runs an ephemeral TI with CubeClearData(). tm1.Clear is not an
+     * alternative on either build: 11.8 and 12.5 both answer "'tm1.Clear'
+     * resource can not be resolved on type 'Cube'" for a cube that exists, and
+     * neither declares a clear action anywhere in $metadata — Cube carries only
+     * Lock and Unlock. CubeClearData() is the only route measured to work, and
+     * it takes a cube name and nothing else, so there is no region to scope.
      */
-    async clear(cubeName, dimensions, tuples) {
-        const isFullClear = dimensions.every((_, i) => (tuples[i] ?? []).length === 0);
-        if (!isFullClear)
-            throw this.partialClearUnsupported(cubeName);
-        await this.clearViaTI(cubeName);
-    }
-    /** Same verdict for both versions: no tuple-selective clear on this server. */
-    partialClearUnsupported(cubeName) {
-        return new TM1Error({
-            code: TM1ErrorCode.UNSUPPORTED_OPERATION,
-            message: `Partial clearCube is not supported on TM1 ${this.http.tm1Version} (no tm1.Clear endpoint). Implement a TI process with bedrock '}bedrock.cube.data.clear' or custom CellPutN loop and call via tm1_execute_process.`,
-            endpoint: `/api/v1/Cubes('${cubeName}')/tm1.Clear`,
-        });
+    async clear(cubeName, opts) {
+        await this.clearViaTI(cubeName, opts);
     }
     /**
      * Unload a cube from memory. Forces TM1 to discard the in-memory fed-cell
@@ -225,10 +209,10 @@ export class CubeService {
      * POST /api/v1/Cubes('{cube}')/tm1.Unload
      */
     async unload(cubeName) {
-        await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/tm1.Unload`);
+        await this.http.request("POST", `/api/v1/Cubes('${odataKey(cubeName)}')/tm1.Unload`);
     }
     // 11.x fallback: deploy ephemeral TI with CubeClearData(), execute, delete.
-    async clearViaTI(cubeName) {
+    async clearViaTI(cubeName, opts) {
         // Cap the sanitized cube name so the temp process name stays under TM1's
         // ~256-char process-name limit (prefix + timestamp suffix add ~25 chars).
         const safeName = cubeName.replace(/[^A-Za-z0-9_]/g, "_").slice(0, 200);
@@ -244,8 +228,29 @@ export class CubeService {
             EpilogProcedure: "",
             DataSource: { Type: "None" },
         });
+        let timedOut = false;
         try {
-            const result = await this.http.request("POST", `/api/v1/Processes('${enc(procName)}')/tm1.ExecuteWithReturn`, {});
+            const result = await this.http
+                .request("POST", `/api/v1/Processes('${odataKey(procName)}')/tm1.ExecuteWithReturn`, {}, opts)
+                .catch((err) => {
+                // A client-side timeout does not stop the TI — but deleting the
+                // process does, when it is still waiting on a lock (measured on
+                // 12.5: the cube kept its data). So on a timeout the process is left
+                // in place to finish; 11.8 held the DELETE until the TI was done
+                // anyway. Reporting a bare timeout would tell the model the cube
+                // still holds its data — the one reading this must not give.
+                if (err instanceof TM1Error &&
+                    err.code === TM1ErrorCode.LOCK_TIMEOUT) {
+                    timedOut = true;
+                    throw new TM1Error({
+                        code: TM1ErrorCode.LOCK_TIMEOUT,
+                        message: `Cube clear for '${cubeName}' did not answer within the request timeout, but the clear keeps running on the server — expect the cube to end up empty. Do not retry; check it with tm1_get_cube_stats once the server is idle. The temporary process '${procName}' was left in place so the clear can finish; delete it afterwards with tm1_delete_process.`,
+                        endpoint: err.endpoint,
+                        hint: "Pass a larger timeoutMs for big cubes or a busy server so the call waits for the clear to finish.",
+                    });
+                }
+                throw err;
+            });
             // ExecuteWithReturn returns HTTP 200 even when the process aborts; the real
             // outcome is in ProcessExecuteStatusCode. Without this check an aborted
             // clear (e.g. lock, security) would be reported as a successful clear.
@@ -277,13 +282,14 @@ export class CubeService {
                     message: verdict.outcome === "rolled_back"
                         ? `Cube clear via TI was rolled back for cube '${cubeName}' (status: ${verdict.processErrorStatus}). Nothing was cleared — the cube is unchanged.`
                         : `Cube clear via TI could not be confirmed for cube '${cubeName}': ${verdict.processErrorStatus} The clear may or may not have run — check the cube before retrying.`,
-                    endpoint: `/api/v1/Processes('${enc(procName)}')/tm1.ExecuteWithReturn`,
+                    endpoint: `/api/v1/Processes('${odataKey(procName)}')/tm1.ExecuteWithReturn`,
                 });
             }
         }
         finally {
             try {
-                await this.http.request("DELETE", `/api/v1/Processes('${enc(procName)}')`);
+                if (!timedOut)
+                    await this.http.request("DELETE", `/api/v1/Processes('${odataKey(procName)}')`);
             }
             catch (cleanupErr) {
                 this.http.logger.warn({ proc: procName, err: String(cleanupErr) }, "Failed to delete ephemeral clearCube TI process — manual cleanup needed");

package/dist/tm1-client/services/dimension-order.d.ts

@@ -0,0 +1,13 @@
+import type { TM1HttpClient } from "../http.js";
+export declare class DimensionOrderCache {
+    private readonly http;
+    private readonly now;
+    private readonly entries;
+    constructor(http: TM1HttpClient, now?: () => number);
+    /**
+     * Ordered dimension names of `cubeName`.
+     * GET /api/v1/Cubes('{name}')?$expand=Dimensions($select=Name)
+     */
+    get(cubeName: string): Promise<string[]>;
+}
+//# sourceMappingURL=dimension-order.d.ts.map

package/dist/tm1-client/services/dimension-order.js

@@ -0,0 +1,42 @@
+import { tm1NameKey } from "../../lib/tm1-name.js";
+import { odataKey as enc } from "./odata-page.js";
+const TTL_MS = 60_000;
+const INERT_PATHS = [/\/ExecuteMDX/i, /\/Cellsets/i];
+export class DimensionOrderCache {
+    http;
+    now;
+    entries = new Map();
+    constructor(http, now = Date.now) {
+        this.http = http;
+        this.now = now;
+        // Test doubles stub only request(); a real client always has the hook.
+        if (typeof http.onMutation === "function") {
+            http.onMutation((e) => {
+                if (!INERT_PATHS.some((re) => re.test(e.path)))
+                    this.entries.clear();
+            });
+        }
+    }
+    /**
+     * Ordered dimension names of `cubeName`.
+     * GET /api/v1/Cubes('{name}')?$expand=Dimensions($select=Name)
+     */
+    get(cubeName) {
+        const key = tm1NameKey(cubeName);
+        const hit = this.entries.get(key);
+        if (hit && this.now() - hit.at < TTL_MS)
+            return hit.dims;
+        // The promise is cached, so concurrent callers share one request; a
+        // failure is evicted so the next call retries instead of replaying it.
+        const dims = this.http
+            .request("GET", `/api/v1/Cubes('${enc(cubeName)}')?$expand=Dimensions($select=Name)`)
+            .then((r) => r.Dimensions.map((d) => d.Name));
+        this.entries.set(key, { dims, at: this.now() });
+        dims.catch(() => {
+            if (this.entries.get(key)?.dims === dims)
+                this.entries.delete(key);
+        });
+        return dims;
+    }
+}
+//# sourceMappingURL=dimension-order.js.map