@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,294 @@
+// Cube domain service. Owns the OData calls under /api/v1/Cubes(...) — listing,
+// creating, deleting, rules, clear, unload. Held as `TM1Client.cubes` and
+// reachable from there so call sites read like `client.cubes.list()` rather
+// than `client.getCubes()`. The flat `getCubes/...` methods on TM1Client remain
+// 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 { classifyExecution } from "./process-status.js";
+// OData key encoder: double ' per OData literal rules, then percent-encode.
+const enc = (s) => encodeURIComponent(String(s).replace(/'/g, "''"));
+export class CubeService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(opts = {}) {
+        // Without a top-level $select TM1 returns every cube property — including
+        // the full Rules text — even on the light path. Pin $select=Name so
+        // list_cubes (and the other name/dimension-only callers) don't drag every
+        // cube's Rules blob over the wire. Only the includeRules path opts Rules in.
+        const select = opts.includeRules ? "Name,Rules" : "Name";
+        // Filters are only emitted on the paged path. Unpaged callers still get the
+        // whole collection and filter in-process, so their behaviour is unchanged.
+        const filter = opts.page === undefined ? "" : filterClause(nameFilterPredicates(opts));
+        const path = `/api/v1/Cubes?$select=${select}&$expand=Dimensions($select=Name)` +
+            `${filter}${pageClauses(opts.page)}`;
+        const response = await this.http.request("GET", path);
+        const items = response.value.map((c) => {
+            const cube = {
+                name: c.Name,
+                dimensions: c.Dimensions.map((d) => d.Name),
+            };
+            if (opts.includeRules) {
+                cube.hasRules = !!(c.Rules && c.Rules.trim().length > 0);
+            }
+            return cube;
+        });
+        return opts.page === undefined
+            ? items
+            : { items, total: readCount(response) };
+    }
+    /**
+     * Return ordered dimension-name list of a cube.
+     * 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);
+    }
+    /**
+     * Cheap existence probe: a single GET with $select=Name (404 → false)
+     * instead of list(), which pulls every cube plus its dimensions just to
+     * check one name. Rethrows anything that isn't NOT_FOUND — in particular a
+     * denial, which is "you may not look", not "it is not there".
+     *
+     * Structural on purpose. The alternative — reading existence out of the
+     * error sentence of a failed query — is wrong on any server whose version
+     * or locale words that sentence differently, and TM1 does both.
+     * GET /api/v1/Cubes('{name}')?$select=Name
+     */
+    async exists(cubeName) {
+        try {
+            await this.http.request("GET", `/api/v1/Cubes('${enc(cubeName)}')?$select=Name`);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof TM1Error && e.code === TM1ErrorCode.NOT_FOUND)
+                return false;
+            throw e;
+        }
+    }
+    /**
+     * Create a new cube with the given dimensions (in order).
+     * POST /api/v1/Cubes
+     */
+    async create(name, dimensionNames) {
+        await this.http.request("POST", "/api/v1/Cubes", {
+            Name: name,
+            Dimensions: dimensionNames.map((d) => ({
+                "@odata.id": `Dimensions('${enc(d)}')`,
+            })),
+        });
+    }
+    /**
+     * Delete a cube.
+     * DELETE /api/v1/Cubes('{name}')
+     */
+    async delete(name) {
+        await this.http.request("DELETE", `/api/v1/Cubes('${enc(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`;
+        // 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`);
+            }
+            catch (probeErr) {
+                if (probeErr instanceof TM1Error && probeErr.httpStatus === 404) {
+                    throw new TM1Error({
+                        code: TM1ErrorCode.NOT_FOUND,
+                        message: `Cube '${cubeName}' does not exist.`,
+                        httpStatus: 404,
+                        endpoint: `/api/v1/Cubes('${cubeName}')`,
+                    });
+                }
+                throw probeErr;
+            }
+            return { cubeName, rulesText: "", skipCheck: false };
+        };
+        try {
+            // TM1 11.8 returns rules text in the "value" field (not "Text")
+            const response = await this.http.request("GET", path);
+            const rulesText = response?.value ?? response?.Text ?? "";
+            if (rulesText === "")
+                return empty();
+            return {
+                cubeName,
+                rulesText,
+                skipCheck: rulesText.toUpperCase().includes("SKIPCHECK"),
+            };
+        }
+        catch (err) {
+            if (err instanceof TM1Error &&
+                (err.httpStatus === 404 || err.httpStatus === 204)) {
+                return empty();
+            }
+            throw err;
+        }
+    }
+    async getAllRules(arg = false, top) {
+        const opts = typeof arg === "object" ? arg : { includeControl: arg };
+        const filter = opts.includeControl
+            ? ""
+            : "&$filter=not startswith(Name,'}')";
+        const expand = opts.withDimensions
+            ? "&$expand=Dimensions($select=Name)"
+            : "";
+        const cap = top !== undefined ? `&$orderby=Name&$top=${top}&$count=true` : "";
+        const path = `/api/v1/Cubes?$select=Name,Rules${expand}${filter}${cap}`;
+        const response = await this.http.request("GET", path);
+        const items = response.value.map((c) => {
+            const rulesText = c.Rules ?? "";
+            return {
+                cubeName: c.Name,
+                rulesText,
+                skipCheck: rulesText.toUpperCase().includes("SKIPCHECK"),
+                ...(c.Dimensions
+                    ? { dimensions: c.Dimensions.map((d) => d.Name) }
+                    : {}),
+            };
+        });
+        if (top !== undefined) {
+            return { items, total: response["@odata.count"] };
+        }
+        return items;
+    }
+    /**
+     * Create or replace the rules for a cube.
+     * TM1 11.8 sets rules by PATCHing the Cube entity ({Rules: "...text..."}).
+     * PATCH/POST on /Cubes('{name}')/Rules returns 400 "not supported".
+     *
+     * There is no skipcheck switch to pass: SKIPCHECK is a line inside the rules
+     * text, so it travels in `rulesText` like every other statement.
+     */
+    async updateRules(cubeName, rulesText) {
+        const cubePath = `/api/v1/Cubes('${enc(cubeName)}')`;
+        await this.http.request("PATCH", cubePath, { Rules: rulesText });
+    }
+    /**
+     * Validate cube rule syntax without applying. Empty array = valid.
+     * POST /api/v1/Cubes('{name}')/tm1.CheckRules with { Rules: "..." }
+     */
+    async checkRule(cubeName, ruleText) {
+        const path = `/api/v1/Cubes('${enc(cubeName)}')/tm1.CheckRules`;
+        const response = await this.http.request("POST", path, { Rules: ruleText });
+        return (response.value ?? []).map((e) => ({
+            message: e.Message,
+            ...(e.LineNumber !== undefined ? { lineNumber: e.LineNumber } : {}),
+        }));
+    }
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    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`,
+        });
+    }
+    /**
+     * 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
+     * to take effect — the fed-cell index is cumulative, so changes to existing
+     * feeders only become visible after an unload.
+     * POST /api/v1/Cubes('{cube}')/tm1.Unload
+     */
+    async unload(cubeName) {
+        await this.http.request("POST", `/api/v1/Cubes('${enc(cubeName)}')/tm1.Unload`);
+    }
+    // 11.x fallback: deploy ephemeral TI with CubeClearData(), execute, delete.
+    async clearViaTI(cubeName) {
+        // 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);
+        const procName = `}TempClear_${safeName}_${Date.now()}`;
+        const safeCube = cubeName.replace(/'/g, "''");
+        const prologCode = `CubeClearData('${safeCube}');`;
+        await this.http.request("POST", "/api/v1/Processes", {
+            Name: procName,
+            HasSecurityAccess: false,
+            PrologProcedure: prologCode,
+            MetadataProcedure: "",
+            DataProcedure: "",
+            EpilogProcedure: "",
+            DataSource: { Type: "None" },
+        });
+        try {
+            const result = await this.http.request("POST", `/api/v1/Processes('${enc(procName)}')/tm1.ExecuteWithReturn`, {});
+            // 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.
+            //
+            // This shares `classifyExecution` with ProcessService rather than
+            // re-deriving `status !== "CompletedSuccessfully"`, because the three
+            // groups mean three different things for a caller holding a cube:
+            //
+            //   committed  — the CubeClearData DID commit (measured: the committed
+            //                statuses leave writes in place). Raising here would tell
+            //                the model the cube still holds its data when it does
+            //                not — the exact false reading this split exists to
+            //                prevent — so the clear stands and the status goes to the
+            //                log instead. Only reachable if TM1 attaches messages to
+            //                a one-line CubeClearData prolog; not observed live.
+            //   rolled back — nothing was cleared; the cube is untouched.
+            //   indeterminate — no status code, or one this build cannot place
+            //                (T-4). Unverified, and for a destructive operation that
+            //                has to surface. A live v11/v12 server always sends the
+            //                field (see tests/live/process.live.test.ts), so this is
+            //                the defensive branch, not the normal path.
+            const verdict = classifyExecution(result?.ProcessExecuteStatusCode, undefined);
+            if (verdict.outcome === "completed_with_errors") {
+                this.http.logger.warn({ cube: cubeName, status: verdict.processErrorStatus }, "Cube clear via TI committed but TM1 reported a non-clean status; the cube IS cleared");
+            }
+            else if (verdict.outcome !== "succeeded") {
+                throw new TM1Error({
+                    code: TM1ErrorCode.TM1_ERROR,
+                    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`,
+                });
+            }
+        }
+        finally {
+            try {
+                await this.http.request("DELETE", `/api/v1/Processes('${enc(procName)}')`);
+            }
+            catch (cleanupErr) {
+                this.http.logger.warn({ proc: procName, err: String(cleanupErr) }, "Failed to delete ephemeral clearCube TI process — manual cleanup needed");
+            }
+        }
+    }
+}
+//# sourceMappingURL=cube-service.js.map

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

@@ -0,0 +1,118 @@
+import type { Dimension } from "../../types.js";
+import type { TM1HttpClient } from "../http.js";
+import { type NameFilterOpts, type Paged, type PageOpts } from "./odata-page.js";
+export type DefaultMemberSource = "defined" | "single_root" | "first_root" | "index_1";
+export interface DefaultMemberResolution {
+    dimension: string;
+    hierarchy: string;
+    resolved: {
+        name: string;
+        level: number;
+    };
+    source: DefaultMemberSource;
+    confidence: "high" | "medium" | "low";
+    alternatives?: {
+        roots: Array<{
+            name: string;
+            level: number;
+        }>;
+        indexOne?: string;
+    };
+    warning?: string;
+}
+/**
+ * Decode a TM1 `}DimensionProperties.LAST_TIME_UPDATED` cell — a 14-digit
+ * `YYYYMMDDHHMMSS` stamp in server-local time — to a naive-local ISO string
+ * (no trailing `Z`, because the value carries no timezone). Returns null for
+ * blank or non-conforming values.
+ */
+export declare function decodeTm1Timestamp(raw: string | number | null | undefined): string | null;
+/**
+ * Normalize a user `changedSince` filter (a date or datetime, interpreted as
+ * server-local — same basis as LAST_TIME_UPDATED) into the 14-digit form so
+ * the two compare by plain string ordering. Date-only pads to start-of-day;
+ * partial times pad missing fields with zero. Throws on fewer than 8 date
+ * digits (need at least a full YYYY-MM-DD).
+ */
+export declare function normalizeChangedSince(input: string): string;
+export interface DimensionListOpts extends NameFilterOpts {
+    includeElementCount?: boolean;
+    includeElementStats?: boolean;
+    /** Set to slice server-side. Only legal when every active filter is in NameFilterOpts. */
+    page?: PageOpts;
+}
+export declare class DimensionService {
+    private readonly http;
+    constructor(http: TM1HttpClient);
+    /**
+     * List all dimensions with their hierarchy names.
+     * GET /api/v1/Dimensions?$expand=Hierarchies($select=Name)
+     *
+     * When opts.includeElementCount is true, the expand also requests
+     * `Elements($count=true;$top=0)` so each Hierarchy returns
+     * `Elements@odata.count` without paying for the full element list.
+     * Single round-trip — drop-in for audit workflows that previously
+     * called getHierarchy() N times just to size dimensions.
+     *
+     * When opts.includeElementStats is true, the expand fetches every
+     * Element's Type+Level so we can aggregate per-Type counts and maxLevel
+     * client-side. TM1 OData rejects `Type eq 'Numeric'` ($filter on enum
+     * properties) and exposes no nested `$apply=groupby`, so a single
+     * full-element scan is the cheapest path — still one round-trip, payload
+     * scales with total element count across all dimensions.
+     * Takes precedence over includeElementCount when both are set.
+     */
+    list(opts?: {
+        includeElementCount?: boolean;
+        includeElementStats?: boolean;
+    }): Promise<Dimension[]>;
+    /**
+     * Paged variant: with `page` set the *outer* /Dimensions collection is
+     * sliced server-side, which is the only lever that bounds the
+     * includeElementStats payload — a 340-dimension model measured 218 MB on the
+     * full scan versus 101 MB for the first 50-dimension page. The nested
+     * Elements expand is still unbounded per dimension (TM1 has no nested
+     * aggregate that would give Type/Level counts without listing elements), so
+     * the win is proportional to how many dimensions the page holds, not
+     * constant.
+     */
+    list(opts: DimensionListOpts & {
+        page: PageOpts;
+    }): Promise<Paged<Dimension>>;
+    /**
+     * Create a new dimension. TM1 11.8 does not auto-create the default
+     * hierarchy from the POST body — we issue an explicit follow-up POST
+     * and tolerate 409 (some versions create it automatically).
+     * POST /api/v1/Dimensions
+     */
+    create(name: string): Promise<void>;
+    /**
+     * Delete a dimension and all its hierarchies.
+     * DELETE /api/v1/Dimensions('{name}')
+     */
+    delete(name: string): Promise<void>;
+    /**
+     * Read per-dimension last-modified timestamps from the `}DimensionProperties`
+     * control cube (`LAST_TIME_UPDATED` measure) in a single MDX round-trip.
+     * Returns a Map of dimension name → raw `YYYYMMDDHHMMSS` string (server-local);
+     * decode with decodeTm1Timestamp(). Dimensions with a blank stamp are absent
+     * from the map. This is a schema-change stamp (structure), bumped on element /
+     * hierarchy / attribute edits — not a data-write stamp.
+     */
+    getLastUpdatedMap(): Promise<Map<string, string>>;
+    /**
+     * Resolve a hierarchy's effective default member via a tiered cascade.
+     * Designed for view/slicer construction where iterating tm1_get_hierarchy
+     * across levels costs 3-8 round-trips per dimension.
+     *
+     * Tier 1: DefaultMember attribute (high confidence — explicitly maintained).
+     * Tier 2: parentless roots (derived, not maintained) — single or multiple = medium.
+     * Tier 3: insertion-order index 1 fallback (low confidence — flat/cyclic hierarchies).
+     *
+     * The `source` field tells callers whether the value is authoritative or inferred.
+     * `alternatives.roots` is populated when multiple roots exist so callers can
+     * disambiguate without a second round-trip.
+     */
+    resolveDefaultMember(dimensionName: string, hierarchyName?: string): Promise<DefaultMemberResolution>;
+}
+//# sourceMappingURL=dimension-service.d.ts.map

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

@@ -0,0 +1,249 @@
+// Dimension domain service. Owns the OData calls under /api/v1/Dimensions(...) —
+// list, create, delete. Hierarchy and element operations live in their own
+// sibling services. See docs/ARCHITECTURE.md for the layering.
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { freeCellset } from "./cellset-transform.js";
+import { filterClause, nameFilterPredicates, pageClauses, readCount, } from "./odata-page.js";
+// OData key encoder: double ' per OData literal rules, then percent-encode.
+const enc = (s) => encodeURIComponent(String(s).replace(/'/g, "''"));
+/**
+ * Decode a TM1 `}DimensionProperties.LAST_TIME_UPDATED` cell — a 14-digit
+ * `YYYYMMDDHHMMSS` stamp in server-local time — to a naive-local ISO string
+ * (no trailing `Z`, because the value carries no timezone). Returns null for
+ * blank or non-conforming values.
+ */
+export function decodeTm1Timestamp(raw) {
+    if (raw === null || raw === undefined)
+        return null;
+    const s = String(raw).trim();
+    if (!/^\d{14}$/.test(s))
+        return null;
+    return (`${s.slice(0, 4)}-${s.slice(4, 6)}-${s.slice(6, 8)}` +
+        `T${s.slice(8, 10)}:${s.slice(10, 12)}:${s.slice(12, 14)}`);
+}
+/**
+ * Normalize a user `changedSince` filter (a date or datetime, interpreted as
+ * server-local — same basis as LAST_TIME_UPDATED) into the 14-digit form so
+ * the two compare by plain string ordering. Date-only pads to start-of-day;
+ * partial times pad missing fields with zero. Throws on fewer than 8 date
+ * digits (need at least a full YYYY-MM-DD).
+ */
+export function normalizeChangedSince(input) {
+    const digits = input.replace(/\D/g, "");
+    if (digits.length < 8) {
+        throw new TM1Error({
+            code: TM1ErrorCode.VALIDATION_ERROR,
+            message: `Invalid changedSince '${input}': need at least a full date (e.g. 2026-04-01).`,
+            details: input,
+        });
+    }
+    return digits.padEnd(14, "0").slice(0, 14);
+}
+export class DimensionService {
+    http;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(opts = {}) {
+        let expand;
+        if (opts?.includeElementStats) {
+            expand = "Hierarchies($select=Name;$expand=Elements($select=Type,Level))";
+        }
+        else if (opts?.includeElementCount) {
+            expand = "Hierarchies($select=Name;$expand=Elements($count=true;$top=0))";
+        }
+        else {
+            expand = "Hierarchies($select=Name)";
+        }
+        // Filters are only emitted on the paged path; unpaged callers keep getting
+        // the whole collection and filter in-process, so nothing changes for them.
+        const filter = opts.page === undefined ? "" : filterClause(nameFilterPredicates(opts));
+        const path = `/api/v1/Dimensions?$expand=${expand}${filter}${pageClauses(opts.page)}`;
+        const response = await this.http.request("GET", path);
+        const items = response.value.map((d) => {
+            const dim = {
+                name: d.Name,
+                hierarchies: d.Hierarchies.map((h) => h.Name),
+            };
+            if (opts?.includeElementStats) {
+                dim.elementStats = Object.fromEntries(d.Hierarchies.map((h) => {
+                    const elements = h.Elements ?? [];
+                    let numeric = 0;
+                    let consolidated = 0;
+                    let stringCount = 0;
+                    let maxLevel = 0;
+                    for (const e of elements) {
+                        if (e.Type === "Numeric")
+                            numeric++;
+                        else if (e.Type === "Consolidated")
+                            consolidated++;
+                        else if (e.Type === "String")
+                            stringCount++;
+                        if (e.Level > maxLevel)
+                            maxLevel = e.Level;
+                    }
+                    return [
+                        h.Name,
+                        {
+                            total: elements.length,
+                            numeric,
+                            consolidated,
+                            string: stringCount,
+                            maxLevel,
+                        },
+                    ];
+                }));
+            }
+            else if (opts?.includeElementCount) {
+                dim.elementCounts = Object.fromEntries(d.Hierarchies.map((h) => [h.Name, h["Elements@odata.count"] ?? 0]));
+            }
+            return dim;
+        });
+        return opts.page === undefined
+            ? items
+            : { items, total: readCount(response) };
+    }
+    /**
+     * Create a new dimension. TM1 11.8 does not auto-create the default
+     * hierarchy from the POST body — we issue an explicit follow-up POST
+     * and tolerate 409 (some versions create it automatically).
+     * POST /api/v1/Dimensions
+     */
+    async create(name) {
+        await this.http.request("POST", "/api/v1/Dimensions", { Name: name });
+        try {
+            await this.http.request("POST", `/api/v1/Dimensions('${enc(name)}')/Hierarchies`, { Name: name });
+        }
+        catch (err) {
+            if (err instanceof TM1Error && err.httpStatus === 409) {
+                return;
+            }
+            throw err;
+        }
+    }
+    /**
+     * Delete a dimension and all its hierarchies.
+     * DELETE /api/v1/Dimensions('{name}')
+     */
+    async delete(name) {
+        await this.http.request("DELETE", `/api/v1/Dimensions('${enc(name)}')`);
+    }
+    /**
+     * Read per-dimension last-modified timestamps from the `}DimensionProperties`
+     * control cube (`LAST_TIME_UPDATED` measure) in a single MDX round-trip.
+     * Returns a Map of dimension name → raw `YYYYMMDDHHMMSS` string (server-local);
+     * decode with decodeTm1Timestamp(). Dimensions with a blank stamp are absent
+     * from the map. This is a schema-change stamp (structure), bumped on element /
+     * hierarchy / attribute edits — not a data-write stamp.
+     */
+    async getLastUpdatedMap() {
+        const mdx = "SELECT {[}DimensionProperties].[LAST_TIME_UPDATED]} ON 0, " +
+            "NON EMPTY [}Dimensions].MEMBERS ON 1 FROM [}DimensionProperties]";
+        const res = await this.http.request("POST", "/api/v1/ExecuteMDX?$expand=Cells($select=Value),Axes($expand=Tuples($expand=Members($select=Name)))", { MDX: mdx });
+        try {
+            const map = new Map();
+            const rows = res.Axes?.[1]?.Tuples ?? [];
+            rows.forEach((tuple, i) => {
+                const name = tuple.Members[0]?.Name;
+                const value = res.Cells[i]?.Value;
+                if (name && value != null && String(value).trim() !== "") {
+                    map.set(name, String(value));
+                }
+            });
+            return map;
+        }
+        finally {
+            // Free the session-scoped cellset best-effort so this metadata read doesn't
+            // leak TM1 server memory while keep-alive holds the session open.
+            await freeCellset(this.http, res.ID);
+        }
+    }
+    /**
+     * Resolve a hierarchy's effective default member via a tiered cascade.
+     * Designed for view/slicer construction where iterating tm1_get_hierarchy
+     * across levels costs 3-8 round-trips per dimension.
+     *
+     * Tier 1: DefaultMember attribute (high confidence — explicitly maintained).
+     * Tier 2: parentless roots (derived, not maintained) — single or multiple = medium.
+     * Tier 3: insertion-order index 1 fallback (low confidence — flat/cyclic hierarchies).
+     *
+     * The `source` field tells callers whether the value is authoritative or inferred.
+     * `alternatives.roots` is populated when multiple roots exist so callers can
+     * disambiguate without a second round-trip.
+     */
+    async resolveDefaultMember(dimensionName, hierarchyName) {
+        const hier = hierarchyName ?? dimensionName;
+        const base = `/api/v1/Dimensions('${enc(dimensionName)}')/Hierarchies('${enc(hier)}')`;
+        // Tier 1: explicit DefaultMember attribute.
+        try {
+            const dm = await this.http.request("GET", `${base}/DefaultMember?$select=Name,Level`);
+            if (dm && dm.Name) {
+                return {
+                    dimension: dimensionName,
+                    hierarchy: hier,
+                    resolved: { name: dm.Name, level: dm.Level ?? 0 },
+                    source: "defined",
+                    confidence: "high",
+                };
+            }
+        }
+        catch (err) {
+            // 404/204 = no default member set; fall through. Other errors bubble.
+            if (!(err instanceof TM1Error &&
+                (err.httpStatus === 404 || err.httpStatus === 204))) {
+                throw err;
+            }
+        }
+        // Tier 2 & 3: enumerate elements with parents and classify.
+        const elementsResp = await this.http.request("GET", `${base}/Elements?$select=Name,Level&$expand=Parents($select=Name)`);
+        const elements = elementsResp?.value ?? [];
+        if (elements.length === 0) {
+            throw new TM1Error({
+                code: TM1ErrorCode.NOT_FOUND,
+                message: `Hierarchy '${dimensionName}.${hier}' has no elements or does not exist`,
+            });
+        }
+        const roots = elements.filter((e) => !e.Parents || e.Parents.length === 0);
+        // elements.length > 0 is guarded above
+        const indexOne = elements[0].Name;
+        if (roots.length === 1) {
+            return {
+                dimension: dimensionName,
+                hierarchy: hier,
+                resolved: { name: roots[0].Name, level: roots[0].Level },
+                source: "single_root",
+                // Derived server-fallback, not an explicitly maintained default → medium,
+                // never tier-1 high. High is reserved for source "defined".
+                confidence: "medium",
+                warning: "DefaultMember attribute not maintained — resolved via unique parentless root.",
+            };
+        }
+        if (roots.length > 1) {
+            // Highest level first, then alphabetical for determinism.
+            const sorted = [...roots].sort((a, b) => b.Level - a.Level || a.Name.localeCompare(b.Name));
+            return {
+                dimension: dimensionName,
+                hierarchy: hier,
+                resolved: { name: sorted[0].Name, level: sorted[0].Level },
+                source: "first_root",
+                confidence: "medium",
+                alternatives: {
+                    roots: sorted.map((r) => ({ name: r.Name, level: r.Level })),
+                    indexOne,
+                },
+                warning: `DefaultMember not maintained — ${roots.length} parentless roots found; selected highest-level. Inspect alternatives.roots to disambiguate.`,
+            };
+        }
+        // No roots: flat or cyclic hierarchy. TM1's own fallback is insertion-order index 1.
+        return {
+            dimension: dimensionName,
+            hierarchy: hier,
+            resolved: { name: indexOne, level: elements[0].Level ?? 0 },
+            source: "index_1",
+            confidence: "low",
+            alternatives: { roots: [], indexOne },
+            warning: "No parentless roots detected (flat or cyclic hierarchy). Falling back to first element by insertion order — verify suitability for view slicers.",
+        };
+    }
+}
+//# sourceMappingURL=dimension-service.js.map