@ffschrattenecker/tm1-mcp-server 6.0.0

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

@@ -0,0 +1,874 @@
+// Process domain service. Owns the OData calls under /api/v1/Processes(...) —
+// listing, executing, code/parameters/variables/datasource CRUD, plus the
+// CompileProcess (server-side syntax check, with and without saving).
+//
+// See docs/ARCHITECTURE.md for the layering.
+import { TM1Error, TM1ErrorCode } from "../../types.js";
+import { isUnsupportedQueryShape, rethrowIfSystemic, rethrowIfSystemicOrDenied, } from "./fallback.js";
+import { classifyExecution } from "./process-status.js";
+import { ignoredColumnsOf } from "../../lib/variables-ui-data.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, "''"));
+function decodeVariable(v) {
+    return {
+        name: v.Name,
+        type: v.Type === "Numeric" ? "Numeric" : "String",
+        position: v.Position,
+        ...(v.StartByte !== undefined ? { startByte: v.StartByte } : {}),
+        ...(v.EndByte !== undefined ? { endByte: v.EndByte } : {}),
+    };
+}
+// Encode a TI parameter for the OData write body.
+//
+// `Type` uses the tm1.ProcessVariableType enum (String=1, Numeric=2 — verified
+// against the live $metadata). On v11 TM1 actually ignores this field and
+// classifies the parameter from the JSON type of `Value`, so the decisive part
+// is coercing `Value` to match the declared `type`: a Numeric parameter whose
+// defaultValue arrived as the string "0" would otherwise be stored as String.
+function encodeParameter(p) {
+    const numeric = p.type === "Numeric";
+    let value;
+    if (numeric) {
+        const n = Number(p.defaultValue);
+        value = Number.isFinite(n) ? n : 0;
+    }
+    else {
+        value = String(p.defaultValue);
+    }
+    return {
+        Name: p.name,
+        Type: numeric ? 2 : 1,
+        Value: value,
+        ...(p.prompt ? { Prompt: p.prompt } : {}),
+    };
+}
+/**
+ * The OData query shapes `fetchForCallgraph` will accept, richest first. Each
+ * later entry gives up something the previous one asked for, so a stricter or
+ * older TM1 that cannot parse one shape can still be served by the next.
+ *
+ * The list is a ladder of CAPABILITY, nothing else: walking down it is only
+ * ever a valid response to the server rejecting the query shape itself.
+ */
+const CALLGRAPH_QUERY_SHAPES = [
+    (f) => `/api/v1/Processes?$select=Name,PrologProcedure,MetadataProcedure,DataProcedure,EpilogProcedure,Parameters${f}`,
+    (f) => `/api/v1/Processes?$select=Name,PrologProcedure,MetadataProcedure,DataProcedure,EpilogProcedure,Parameters&$expand=Parameters($select=Name,Value,Type)${f}`,
+    (f) => `/api/v1/Processes?$expand=Parameters${f}`,
+    // Last resort: no parameter metadata at all. Callgraph edges still resolve;
+    // parameter-default folding degrades.
+    (f) => `/api/v1/Processes?$select=Name,PrologProcedure,MetadataProcedure,DataProcedure,EpilogProcedure${f}`,
+];
+export class ProcessService {
+    http;
+    /**
+     * Index into `CALLGRAPH_QUERY_SHAPES` that this connection answered, or
+     * `null` while unprobed — the same tri-state verdict `BatchService.supported`
+     * keeps, for the same reason. Probing costs up to four full `/Processes`
+     * scans, so it must be paid once per connection and not once per callgraph
+     * build (P7).
+     */
+    callgraphShape = null;
+    constructor(http) {
+        this.http = http;
+    }
+    async list(opts = {}) {
+        // Filters are only emitted on the paged path; unpaged callers keep getting
+        // the whole collection and filter in-process. The degraded Name-only
+        // retry below reuses the same query — dropping it there would turn a
+        // paged request into a silent full, unfiltered fetch.
+        const query = opts.page === undefined
+            ? ""
+            : `${filterClause(nameFilterPredicates(opts))}${pageClauses(opts.page)}`;
+        const wrap = (items, total) => opts.page === undefined ? items : { items, total };
+        // Parameters is a structural (complex) property, not a navigation property
+        // — TM1 v11 rejects $expand=Parameters with a syntax error. Use $select
+        // instead, which returns Parameters inline. Param.Type comes back as the
+        // already-decoded string "Numeric" / "String" (not the legacy int code).
+        try {
+            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name,Parameters${query}`);
+            return wrap(response.value.map((p) => ({
+                name: p.Name,
+                parameters: (p.Parameters ?? []).map((param) => ({
+                    name: param.Name,
+                    type: param.Type === "Numeric" ? "Numeric" : "String",
+                    defaultValue: param.Value,
+                    ...(param.Prompt ? { prompt: param.Prompt } : {}),
+                })),
+            })), readCount(response));
+        }
+        catch (e) {
+            rethrowIfSystemic(e);
+            const response = await this.http.request("GET", `/api/v1/Processes?$select=Name${query}`);
+            return wrap(response.value.map((p) => ({
+                name: p.Name,
+                parameters: [],
+            })), readCount(response));
+        }
+    }
+    /**
+     * Execute a TI process with optional parameters. opts.timeoutMs overrides
+     * the 30s default for long-running TI runs.
+     * POST /api/v1/Processes('{name}')/tm1.ExecuteWithReturn?$expand=ErrorLogFile
+     */
+    async execute(processName, params, opts) {
+        // $expand=ErrorLogFile is REQUIRED, not an optimization: ErrorLogFile is a
+        // navigation property on ProcessExecuteResult, so an unexpanded call returns
+        // only ProcessExecuteStatusCode and the filename is silently absent. Measured
+        // on 11.8.02900.8 and 12.5.9 — both omit the key entirely without it, and both
+        // return {"Filename": ...} with it (v11 `TM1ProcessError_*.log`, v12
+        // `ProcessLog_*.jsonl`).
+        const path = `/api/v1/Processes('${enc(processName)}')/tm1.ExecuteWithReturn?$expand=ErrorLogFile`;
+        const body = {};
+        if (params && Object.keys(params).length > 0) {
+            body.Parameters = Object.entries(params).map(([name, value]) => ({
+                Name: name,
+                Value: value,
+            }));
+        }
+        try {
+            // ExecuteWithReturn returns HTTP 200 even when the process aborts; the
+            // real outcome is in ProcessExecuteStatusCode. The plain tm1.Execute
+            // action also 2xx-es on CompletedWithMinorErrors/HasMinorErrors, which
+            // made partial failures (bad records + error log) invisible.
+            const response = await this.http.request("POST", path, body, opts);
+            return classifyExecution(response?.ProcessExecuteStatusCode, response?.ErrorLogFile?.Filename);
+        }
+        catch (error) {
+            // Systemic transport/auth failures (LOCK_TIMEOUT, CONNECTION_FAILED,
+            // AUTH_FAILED) must propagate: a timed-out TI run is still executing
+            // server-side, so reporting {success:false} would invite a duplicate run.
+            rethrowIfSystemic(error);
+            // The call itself errored, so TM1 never reported a status — and an error
+            // raised mid-run says nothing about whether the run committed. That is
+            // `indeterminate` by definition, not a rollback we can promise; the
+            // server's own text rides along in processErrorStatus so the caller still
+            // sees WHY.
+            if (error instanceof TM1Error) {
+                return {
+                    success: false,
+                    outcome: "indeterminate",
+                    processErrorStatus: error.details ?? error.message,
+                    errorLogFile: undefined,
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Persist in-memory cube data to disk — SaveDataAll (all cubes) or
+     * CubeSaveData (single cube). The REST API exposes no native SaveData
+     * action ($metadata verified), so this routes through the service-root
+     * ExecuteProcessWithReturn (available since 11.3) with an unbound TI
+     * process — no persistent process object is created. v11-only: both TI
+     * functions are removed in v12 (cloud engine persists automatically).
+     * POST /api/v1/ExecuteProcessWithReturn
+     */
+    async saveData(cubeName, opts) {
+        const prolog = cubeName !== undefined
+            ? `CubeSaveData('${cubeName.replace(/'/g, "''")}');`
+            : "SaveDataAll;";
+        const body = {
+            Process: {
+                Name: "}tm1-mcp-save-data",
+                HasSecurityAccess: false,
+                PrologProcedure: prolog,
+                MetadataProcedure: "",
+                DataProcedure: "",
+                EpilogProcedure: "",
+                DataSource: { Type: "None" },
+            },
+        };
+        try {
+            const response = await this.http.request("POST", 
+            // See executeProcess: without $expand the ErrorLogFile nav property is
+            // never serialized, on either version.
+            "/api/v1/ExecuteProcessWithReturn?$expand=ErrorLogFile", body, opts);
+            return classifyExecution(response?.ProcessExecuteStatusCode, response?.ErrorLogFile?.Filename);
+        }
+        catch (error) {
+            // Systemic transport/auth failures (LOCK_TIMEOUT, CONNECTION_FAILED,
+            // AUTH_FAILED) must propagate: a timed-out TI run is still executing
+            // server-side, so reporting {success:false} would invite a duplicate run.
+            rethrowIfSystemic(error);
+            // The call itself errored, so TM1 never reported a status — and an error
+            // raised mid-run says nothing about whether the run committed. That is
+            // `indeterminate` by definition, not a rollback we can promise; the
+            // server's own text rides along in processErrorStatus so the caller still
+            // sees WHY.
+            if (error instanceof TM1Error) {
+                return {
+                    success: false,
+                    outcome: "indeterminate",
+                    processErrorStatus: error.details ?? error.message,
+                    errorLogFile: undefined,
+                };
+            }
+            throw error;
+        }
+    }
+    /**
+     * Get the parameters of a TI process.
+     * GET /api/v1/Processes('{name}')/Parameters
+     */
+    async getParameters(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')/Parameters`;
+        // TM1 v11 returns Type as the decoded string "Numeric" / "String"
+        // (not the legacy int code 1 / 2). The old `=== 1` check silently
+        // classified every Numeric parameter as String.
+        const response = await this.http.request("GET", path);
+        return response.value.map((param) => ({
+            name: param.Name,
+            type: param.Type === "Numeric" ? "Numeric" : "String",
+            defaultValue: param.Value,
+            ...(param.Prompt ? { prompt: param.Prompt } : {}),
+        }));
+    }
+    /**
+     * Create a new empty TI process.
+     * POST /api/v1/Processes with body {"Name": "..."}
+     * Throws CONFLICT (409) if a process with the same name already exists.
+     */
+    async create(name) {
+        await this.http.request("POST", "/api/v1/Processes", { Name: name });
+    }
+    /**
+     * Cheap existence probe: a single GET with $select=Name (404 → false)
+     * instead of list(), which pulls every process plus its parameters just to
+     * check one name. Rethrows anything that isn't NOT_FOUND.
+     */
+    async exists(name) {
+        try {
+            await this.http.request("GET", `/api/v1/Processes('${enc(name)}')?$select=Name`);
+            return true;
+        }
+        catch (e) {
+            if (e instanceof TM1Error && e.code === TM1ErrorCode.NOT_FOUND)
+                return false;
+            throw e;
+        }
+    }
+    /**
+     * Copy a TI process to a new name. Strips read-only / server-managed fields
+     * before re-POSTing to avoid TM1 rejecting the body.
+     */
+    async copy(sourceName, targetName) {
+        const path = `/api/v1/Processes('${enc(sourceName)}')`;
+        const source = await this.http.request("GET", path);
+        delete source["@odata.context"];
+        delete source["@odata.etag"];
+        delete source["Attributes"];
+        delete source["LocalizedAttributes"];
+        // `UIData` and `VariablesUIData` are undeclared in $metadata on both
+        // versions, so the plain GET above never returns them. Without the second
+        // request the copy silently loses every ignored datasource column (the
+        // ignore flag lives ONLY in VariablesUIData) and the Architect action
+        // settings — measured on 11.8 and 12.5.
+        const ui = await this.getUIData(sourceName);
+        if (ui.uiData !== undefined)
+            source.UIData = ui.uiData;
+        if (ui.variablesUIData !== undefined)
+            source.VariablesUIData = ui.variablesUIData;
+        source.Name = targetName;
+        await this.http.request("POST", "/api/v1/Processes", source);
+    }
+    /**
+     * The two UI-only properties TM1 stores but does not declare: `UIData`
+     * (Architect cube/data action settings) and `VariablesUIData` (per-column
+     * state, including which columns are ignored). Both have to be named in
+     * `$select`; a server that rejects the query shape yields an empty result
+     * rather than an error, since neither is required to use the process.
+     */
+    async getUIData(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')` +
+            `?$select=UIData,VariablesUIData`;
+        try {
+            const r = await this.http.request("GET", path);
+            return {
+                ...(r.UIData !== undefined ? { uiData: r.UIData } : {}),
+                ...(r.VariablesUIData !== undefined
+                    ? { variablesUIData: r.VariablesUIData }
+                    : {}),
+            };
+        }
+        catch (e) {
+            rethrowIfSystemic(e);
+            if (!isUnsupportedQueryShape(e))
+                throw e;
+            return {};
+        }
+    }
+    /**
+     * Run the callgraph fetch against the query shape this connection accepts,
+     * discovering it on first use.
+     *
+     * The discovery loop used to catch EVERY error and move on to the next,
+     * broader query. That turned an expired session, a request timeout or a
+     * security denial into three more full-collection scans (~4 × 30 s worst
+     * case, P7) and — worse — let a later shape that happened to answer mask the
+     * real first error (K6/T-9). Two guards now bound it:
+     *
+     *   - `rethrowIfSystemicOrDenied` — transport/auth/timeout failures and
+     *     permission denials leave immediately. A denial in particular must never
+     *     become an empty process list: the callgraph would cache "this model has
+     *     no processes" as truth.
+     *   - `isUnsupportedQueryShape` — of what is left, only TM1 refusing the
+     *     query shape justifies asking again in another form.
+     */
+    async fetchCallgraphBody(filter) {
+        const shapeAt = (i) => {
+            const build = CALLGRAPH_QUERY_SHAPES[i];
+            if (build === undefined)
+                throw new Error(`No callgraph query shape at index ${i}`);
+            return build(filter);
+        };
+        if (this.callgraphShape !== null) {
+            try {
+                return await this.http.request("GET", shapeAt(this.callgraphShape));
+            }
+            catch (e) {
+                // A shape this server has already answered cannot suddenly be
+                // "unsupported" — mirrors BatchService, where a 400 after the first
+                // success means the request was bad, not the feature missing. Drop the
+                // verdict so a genuinely changed server is re-probed next call, and let
+                // the error surface instead of silently re-walking the ladder.
+                this.callgraphShape = null;
+                throw e;
+            }
+        }
+        let lastErr;
+        for (let i = 0; i < CALLGRAPH_QUERY_SHAPES.length; i++) {
+            try {
+                const body = await this.http.request("GET", shapeAt(i));
+                this.callgraphShape = i;
+                return body;
+            }
+            catch (e) {
+                rethrowIfSystemicOrDenied(e);
+                if (!isUnsupportedQueryShape(e))
+                    throw e;
+                lastErr = e;
+            }
+        }
+        throw lastErr instanceof Error
+            ? lastErr
+            : new Error(String(lastErr ?? "Processes fetch failed"));
+    }
+    /**
+     * Fetch every TI process with code AND parameter metadata for callgraph
+     * indexing. Single round trip once the connection's usable OData query shape
+     * is known — see `fetchCallgraphBody` for the discovery rules.
+     */
+    async fetchForCallgraph(includeControl = false) {
+        const filter = includeControl ? "" : "&$filter=not startswith(Name,'}')";
+        const body = await this.fetchCallgraphBody(filter);
+        return (body.value ?? [])
+            .map((p) => {
+            const parameters = (p.Parameters ?? [])
+                .map((x) => String(x.Name ?? ""))
+                .filter((n) => n !== "");
+            const parameterDefaults = new Map();
+            for (const x of p.Parameters ?? []) {
+                if (x.Name &&
+                    x.Value !== undefined &&
+                    x.Value !== null &&
+                    x.Value !== "") {
+                    parameterDefaults.set(String(x.Name), String(x.Value));
+                }
+            }
+            return {
+                name: String(p.Name ?? ""),
+                prolog: String(p.PrologProcedure ?? ""),
+                metadata: String(p.MetadataProcedure ?? ""),
+                data: String(p.DataProcedure ?? ""),
+                epilog: String(p.EpilogProcedure ?? ""),
+                parameters,
+                parameterDefaults,
+            };
+        })
+            .filter((p) => p.name !== "");
+    }
+    async getAllCode(includeControl = false, top) {
+        const filter = includeControl ? "" : "&$filter=not startswith(Name,'}')";
+        const cap = top !== undefined ? `&$orderby=Name&$top=${top}&$count=true` : "";
+        const path = `/api/v1/Processes?$select=Name,PrologProcedure,MetadataProcedure,DataProcedure,EpilogProcedure,HasSecurityAccess${filter}${cap}`;
+        const response = await this.http.request("GET", path);
+        const items = response.value.map((p) => ({
+            name: p.Name,
+            prolog: p.PrologProcedure ?? "",
+            metadata: p.MetadataProcedure ?? "",
+            data: p.DataProcedure ?? "",
+            epilog: p.EpilogProcedure ?? "",
+            hasSecurityAccess: p.HasSecurityAccess === true,
+        }));
+        if (top !== undefined) {
+            return { items, total: response["@odata.count"] };
+        }
+        return items;
+    }
+    /**
+     * Get the code of all four tabs of a TI process.
+     * GET /api/v1/Processes('{name}')
+     */
+    async getCode(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const response = await this.http.request("GET", path);
+        return {
+            prolog: response.PrologProcedure,
+            metadata: response.MetadataProcedure,
+            data: response.DataProcedure,
+            epilog: response.EpilogProcedure,
+        };
+    }
+    /**
+     * Read deploy-relevant entity metadata not covered by getCode/params/
+     * vars/datasource. Currently only HasSecurityAccess (functional elevation).
+     * GET /api/v1/Processes('{name}')?$select=HasSecurityAccess
+     */
+    async getDeployMeta(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')?$select=HasSecurityAccess`;
+        const response = await this.http.request("GET", path);
+        return { hasSecurityAccess: response.HasSecurityAccess === true };
+    }
+    /**
+     * Update one or more code tabs of a TI process (partial update).
+     * PATCH /api/v1/Processes('{name}') with only the tabs to update.
+     */
+    async updateCode(processName, code) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const body = {};
+        if (code.prolog !== undefined)
+            body.PrologProcedure = code.prolog;
+        if (code.metadata !== undefined)
+            body.MetadataProcedure = code.metadata;
+        if (code.data !== undefined)
+            body.DataProcedure = code.data;
+        if (code.epilog !== undefined)
+            body.EpilogProcedure = code.epilog;
+        await this.http.request("PATCH", path, body);
+    }
+    /**
+     * Read the whole process code as TM1's native `#region <Tab>` / `#endregion`
+     * blob. GET /api/v1/Processes('{name}')/Code/$value (text/plain). Empty tabs
+     * are omitted by the server; newlines are CRLF.
+     */
+    async getCodeBlob(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')/Code/$value`;
+        return this.http.requestRaw("GET", path);
+    }
+    /**
+     * Write the whole process code from a native `#region` blob. PATCH
+     * /api/v1/Processes('{name}') { Code }. The server parses the region markers
+     * and does a FULL replace of all four tabs — tabs whose region is absent are
+     * cleared. `$value` PUT is not supported by TM1, so this JSON PATCH is the
+     * only write path.
+     */
+    async updateCodeBlob(processName, blob) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        await this.http.request("PATCH", path, { Code: blob });
+    }
+    /**
+     * Set HasSecurityAccess flag on process.
+     * PATCH /api/v1/Processes('{name}') { HasSecurityAccess }.
+     */
+    async updateSecurityAccess(processName, hasSecurityAccess) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        await this.http.request("PATCH", path, {
+            HasSecurityAccess: hasSecurityAccess,
+        });
+    }
+    /**
+     * Get the data source configuration of a TI process.
+     * GET /api/v1/Processes('{name}') and extract the DataSource field.
+     */
+    /**
+     * Read a process datasource. The ODBC password is redacted by default so it
+     * cannot reach the caller or the model; `includeSecrets` returns it verbatim
+     * and is meant for export paths that write straight to a file.
+     *
+     * Measured on 11.8: the value on the wire is a server-bound ciphertext
+     * (`W0br…==`) that TM1 stores unchanged when written back, so it survives a
+     * round trip on the same instance but decrypts to nothing on another one.
+     * TM1 v12 returns the password in plain text.
+     */
+    async getDataSource(processName, opts) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const response = await this.http.request("GET", path);
+        const ds = response.DataSource;
+        // ds.Type is a raw string from the OData response. Surface (don't silently
+        // swallow) a type this client version doesn't know — a future TM1 API
+        // value would otherwise be cast to DataSource["type"] and could break a
+        // downstream switch (e.g. the .pro serializer's type map). Pass it through
+        // for forward-compat reads, but log so the gap is observable.
+        const KNOWN_DATASOURCE_TYPES = [
+            "None",
+            "TM1CubeView",
+            "TM1DimensionSubset",
+            "ASCII",
+            "ODBC",
+            "TM1Process",
+        ];
+        if (!KNOWN_DATASOURCE_TYPES.includes(ds.Type)) {
+            this.http.logger.warn({ processName, dataSourceType: ds.Type }, "Unknown TI datasource type from TM1; passing through unchanged");
+        }
+        return {
+            type: ds.Type,
+            ...(ds.dataSourceNameForServer !== undefined
+                ? { dataSourceNameForServer: ds.dataSourceNameForServer }
+                : {}),
+            ...(ds.dataSourceNameForClient !== undefined
+                ? { dataSourceNameForClient: ds.dataSourceNameForClient }
+                : {}),
+            ...(ds.asciiDelimiterType !== undefined
+                ? { asciiDelimiterType: ds.asciiDelimiterType }
+                : {}),
+            ...(ds.asciiDelimiterChar !== undefined
+                ? { asciiDelimiterChar: ds.asciiDelimiterChar }
+                : {}),
+            ...(ds.asciiQuoteCharacter !== undefined
+                ? { asciiQuoteCharacter: ds.asciiQuoteCharacter }
+                : {}),
+            ...(ds.asciiHeaderRecords !== undefined
+                ? { asciiHeaderRecords: ds.asciiHeaderRecords }
+                : {}),
+            ...(ds.asciiDecimalSeparator !== undefined
+                ? { asciiDecimalSeparator: ds.asciiDecimalSeparator }
+                : {}),
+            ...(ds.asciiThousandSeparator !== undefined
+                ? { asciiThousandSeparator: ds.asciiThousandSeparator }
+                : {}),
+            ...(ds.usesUnicode !== undefined ? { usesUnicode: ds.usesUnicode } : {}),
+            ...(ds.userName !== undefined ? { userName: ds.userName } : {}),
+            // Never surface the ODBC datasource password to the caller/LLM — return a
+            // presence marker so the field stays observable without leaking the credential.
+            ...(ds.password !== undefined
+                ? {
+                    password: opts?.includeSecrets
+                        ? ds.password
+                        : ds.password
+                            ? "[redacted]"
+                            : "",
+                }
+                : {}),
+            ...(ds.query !== undefined ? { query: ds.query } : {}),
+            ...(ds.view !== undefined ? { view: ds.view } : {}),
+            ...(ds.subset !== undefined ? { subset: ds.subset } : {}),
+        };
+    }
+    /**
+     * Bulk-fetch the datasource of every process in one OData call, projected to
+     * the few fields data-flow analysis needs (type + source object). Credentials
+     * are never selected. Used by tm1_trace_data_flow to detect view-sourced reads
+     * that leave no CellGet in the code and so never reach the reference index.
+     * GET /api/v1/Processes?$select=Name,DataSource
+     */
+    async listDataSources(includeControl = false) {
+        const filter = includeControl ? "" : "&$filter=not startswith(Name,'}')";
+        const path = `/api/v1/Processes?$select=Name,DataSource${filter}`;
+        const response = await this.http.request("GET", path);
+        return response.value
+            .filter((p) => typeof p.Name === "string")
+            .map((p) => {
+            const ds = p.DataSource;
+            return {
+                name: p.Name,
+                type: ds?.Type ?? "None",
+                ...(ds?.dataSourceNameForServer !== undefined
+                    ? { sourceName: ds.dataSourceNameForServer }
+                    : {}),
+                ...(ds?.view !== undefined ? { view: ds.view } : {}),
+                ...(ds?.subset !== undefined ? { subset: ds.subset } : {}),
+            };
+        });
+    }
+    /**
+     * Update the data source configuration of a TI process.
+     * PATCH /api/v1/Processes('{name}') with DataSource object.
+     */
+    async updateDataSource(processName, dataSource) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const dsBody = { Type: dataSource.type };
+        if (dataSource.dataSourceNameForServer !== undefined)
+            dsBody.dataSourceNameForServer = dataSource.dataSourceNameForServer;
+        if (dataSource.dataSourceNameForClient !== undefined)
+            dsBody.dataSourceNameForClient = dataSource.dataSourceNameForClient;
+        if (dataSource.asciiDelimiterType !== undefined)
+            dsBody.asciiDelimiterType = dataSource.asciiDelimiterType;
+        if (dataSource.asciiDelimiterChar !== undefined)
+            dsBody.asciiDelimiterChar = dataSource.asciiDelimiterChar;
+        if (dataSource.asciiQuoteCharacter !== undefined)
+            dsBody.asciiQuoteCharacter = dataSource.asciiQuoteCharacter;
+        if (dataSource.asciiHeaderRecords !== undefined)
+            dsBody.asciiHeaderRecords = dataSource.asciiHeaderRecords;
+        if (dataSource.asciiDecimalSeparator !== undefined)
+            dsBody.asciiDecimalSeparator = dataSource.asciiDecimalSeparator;
+        if (dataSource.asciiThousandSeparator !== undefined)
+            dsBody.asciiThousandSeparator = dataSource.asciiThousandSeparator;
+        if (dataSource.usesUnicode !== undefined) {
+            if (acceptsUsesUnicode(dataSource.type)) {
+                dsBody.usesUnicode = dataSource.usesUnicode;
+            }
+            else {
+                this.http.logger.warn({ processName, dataSourceType: dataSource.type }, "DataSource.usesUnicode applies to ODBC sources only and is being dropped from the PATCH (TM1 rejects it as 'unprocessed properties' for other types)");
+            }
+        }
+        if (dataSource.userName !== undefined)
+            dsBody.userName = dataSource.userName;
+        if (dataSource.password !== undefined)
+            dsBody.password = dataSource.password;
+        if (dataSource.query !== undefined)
+            dsBody.query = dataSource.query;
+        if (dataSource.view !== undefined)
+            dsBody.view = dataSource.view;
+        if (dataSource.subset !== undefined)
+            dsBody.subset = dataSource.subset;
+        await this.http.request("PATCH", path, { DataSource: dsBody });
+    }
+    /**
+     * Get the variables (column-mapped names) of a TI process.
+     * GET /api/v1/Processes('{name}')/Variables
+     */
+    async getVariables(processName) {
+        return (await this.getVariableLayout(processName)).variables;
+    }
+    /**
+     * Variables PLUS the columns the process ignores, in one request.
+     *
+     * `Variables` alone is an incomplete picture of the datasource: a column set
+     * to "Ignore" carries no variable and is simply absent from the list, which
+     * is why the remaining positions have gaps. The ignore flag lives in
+     * `VariablesUIData` — one entry per source column, undeclared in $metadata on
+     * both versions, so it must be named in `$select`.
+     *
+     * GET /api/v1/Processes('{name}')?$select=Variables,VariablesUIData
+     */
+    async getVariableLayout(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')` +
+            `?$select=Variables,VariablesUIData`;
+        try {
+            const r = await this.http.request("GET", path);
+            return {
+                variables: (r.Variables ?? []).map(decodeVariable),
+                ignoredColumns: ignoredColumnsOf(r.VariablesUIData),
+                ...(r.VariablesUIData !== undefined
+                    ? { variablesUIData: r.VariablesUIData }
+                    : {}),
+            };
+        }
+        catch (e) {
+            rethrowIfSystemic(e);
+            if (!isUnsupportedQueryShape(e))
+                throw e;
+            // A server that will not answer the $select still answers the plain
+            // collection — variables without the ignore information beat no answer.
+            const response = await this.http.request("GET", `/api/v1/Processes('${enc(processName)}')/Variables`);
+            return {
+                variables: response.value.map(decodeVariable),
+                ignoredColumns: [],
+            };
+        }
+    }
+    /**
+     * Variables of every process, in ONE request.
+     *
+     * `Variables` is a complex-typed property, not a navigation collection, so
+     * the process list can carry it directly — no `$expand`, and no follow-up
+     * call per process. `getVariables` above answers the same question for a
+     * single process and stays the right tool when that is all you need.
+     *
+     * The difference is not cosmetic: asking per process costs one round trip
+     * each, which on a 221-process model measured as 221 extra requests against
+     * a single 147 KB one. Whole-model analyses (audit_complexity) use this.
+     *
+     * GET /api/v1/Processes?$select=Name,Variables
+     */
+    async getAllVariables(includeControl = false) {
+        const filter = includeControl ? "" : "&$filter=not startswith(Name,'}')";
+        const path = `/api/v1/Processes?$select=Name,Variables${filter}`;
+        const response = await this.http.request("GET", path);
+        const byProcess = new Map();
+        for (const p of response.value) {
+            // A process without variables comes back with the property omitted
+            // rather than as an empty array.
+            byProcess.set(p.Name, (p.Variables ?? []).map(decodeVariable));
+        }
+        return byProcess;
+    }
+    /**
+     * Update the variables of a TI process (column-name mapping for ASCII/ODBC sources).
+     * Required after setting an ASCII DataSource.
+     * PATCH /api/v1/Processes('{name}') with Variables array.
+     */
+    async updateVariables(processName, vars, variablesUIData) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const body = {
+            Variables: vars.map((v) => ({
+                Name: v.name,
+                Type: v.type,
+                Position: v.position,
+                StartByte: v.startByte ?? 0,
+                EndByte: v.endByte ?? 0,
+            })),
+        };
+        // Patching Variables alone leaves whatever VariablesUIData the process
+        // already has (measured on 12.5), which is right for an edit that keeps the
+        // column layout and wrong for one that changes it — hence the explicit
+        // parameter for callers that carry the source layout (git/.pro import).
+        if (variablesUIData !== undefined)
+            body.VariablesUIData = variablesUIData;
+        await this.http.request("PATCH", path, body);
+    }
+    /**
+     * Update the parameters of a TI process.
+     * PATCH /api/v1/Processes('{name}') with Parameters array.
+     */
+    async updateParameters(processName, params) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        const body = {
+            Parameters: params.map(encodeParameter),
+        };
+        await this.http.request("PATCH", path, body);
+    }
+    /**
+     * Delete a TI process.
+     * DELETE /api/v1/Processes('{name}')
+     */
+    async delete(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')`;
+        await this.http.request("DELETE", path);
+    }
+    /**
+     * Compile a saved TI process to check syntax without executing it.
+     * POST /api/v1/Processes('{name}')/tm1.Compile
+     */
+    async compile(processName) {
+        const path = `/api/v1/Processes('${enc(processName)}')/tm1.Compile`;
+        try {
+            const response = await this.http.request("POST", path, {});
+            const errors = (response?.value ?? []).map((e) => ({
+                lineNumber: e.LineNumber,
+                procedure: e.Procedure,
+                message: e.Message ?? "",
+            }));
+            return { success: errors.length === 0, errors };
+        }
+        catch (err) {
+            // Systemic transport/auth failures must propagate rather than be reported
+            // as a compile failure — an outage is not a broken process.
+            rethrowIfSystemic(err);
+            if (err instanceof TM1Error) {
+                return {
+                    success: false,
+                    errors: [{ message: err.details ?? err.message }],
+                };
+            }
+            throw err;
+        }
+    }
+    /**
+     * Validate a TI process WITHOUT saving it on the server. Mirrors tm1py's
+     * compile_process_with_body. Returns CompileResult identical to compile()
+     * for callers that already handle that shape.
+     * POST /api/v1/CompileProcess body { Process: <full process body> }
+     */
+    async check(input) {
+        const path = "/api/v1/CompileProcess";
+        const processBody = {
+            Name: input.name ?? "_compile_check",
+            PrologProcedure: input.prolog ?? "",
+            MetadataProcedure: input.metadata ?? "",
+            DataProcedure: input.data ?? "",
+            EpilogProcedure: input.epilog ?? "",
+        };
+        if (input.parameters) {
+            processBody.Parameters = input.parameters.map(encodeParameter);
+        }
+        if (input.variables) {
+            processBody.Variables = input.variables.map((v) => ({
+                Name: v.name,
+                Type: v.type,
+                Position: v.position,
+                StartByte: v.startByte ?? 0,
+                EndByte: v.endByte ?? 0,
+            }));
+        }
+        if (input.dataSource) {
+            const ds = input.dataSource;
+            const dsBody = { Type: ds.type };
+            if (ds.dataSourceNameForServer !== undefined)
+                dsBody.dataSourceNameForServer = ds.dataSourceNameForServer;
+            if (ds.dataSourceNameForClient !== undefined)
+                dsBody.dataSourceNameForClient = ds.dataSourceNameForClient;
+            if (ds.asciiDelimiterType !== undefined)
+                dsBody.asciiDelimiterType = ds.asciiDelimiterType;
+            if (ds.asciiDelimiterChar !== undefined)
+                dsBody.asciiDelimiterChar = ds.asciiDelimiterChar;
+            if (ds.asciiQuoteCharacter !== undefined)
+                dsBody.asciiQuoteCharacter = ds.asciiQuoteCharacter;
+            if (ds.asciiHeaderRecords !== undefined)
+                dsBody.asciiHeaderRecords = ds.asciiHeaderRecords;
+            if (ds.asciiDecimalSeparator !== undefined)
+                dsBody.asciiDecimalSeparator = ds.asciiDecimalSeparator;
+            if (ds.asciiThousandSeparator !== undefined)
+                dsBody.asciiThousandSeparator = ds.asciiThousandSeparator;
+            // usesUnicode: ODBC-only, on every version — see acceptsUsesUnicode().
+            if (ds.usesUnicode !== undefined && acceptsUsesUnicode(ds.type)) {
+                dsBody.usesUnicode = ds.usesUnicode;
+            }
+            if (ds.userName !== undefined)
+                dsBody.userName = ds.userName;
+            if (ds.password !== undefined)
+                dsBody.password = ds.password;
+            if (ds.query !== undefined)
+                dsBody.query = ds.query;
+            if (ds.view !== undefined)
+                dsBody.view = ds.view;
+            if (ds.subset !== undefined)
+                dsBody.subset = ds.subset;
+            processBody.DataSource = dsBody;
+        }
+        else {
+            processBody.DataSource = { Type: "None" };
+        }
+        try {
+            const response = await this.http.request("POST", path, { Process: processBody });
+            const errors = (response?.value ?? []).map((e) => ({
+                lineNumber: e.LineNumber,
+                procedure: e.Procedure,
+                message: e.Message ?? "",
+            }));
+            return { success: errors.length === 0, errors };
+        }
+        catch (err) {
+            // Systemic transport/auth failures must propagate rather than be reported
+            // as a compile failure — an outage is not a broken process.
+            rethrowIfSystemic(err);
+            if (err instanceof TM1Error) {
+                return {
+                    success: false,
+                    errors: [{ message: err.details ?? err.message }],
+                };
+            }
+            throw err;
+        }
+    }
+}
+/**
+ * `usesUnicode` is an ODBC datasource setting, not a version-specific one.
+ *
+ * It was carried here as "v12-only, TM1 11.x rejects it", which had it exactly
+ * backwards. TM1 validates datasource properties per source type: 11.8 rejects
+ * usesUnicode for an ASCII source ("unprocessed properties") but accepts it for
+ * an ODBC one, returns it from a plain GET, and writes it to the .pro file as
+ * line 559 (`usesUnicode: true` → `559,1`, `false` → `559,0`) — measured on
+ * both. On 12.5 the property is never returned for any source type, so there is
+ * no evidence it exists there; sending it costs nothing, since v12 silently
+ * ignores properties it does not know.
+ *
+ * Gating on the source type therefore serves both versions correctly, which
+ * gating on the version never did.
+ */
+function acceptsUsesUnicode(type) {
+    return type === "ODBC";
+}
+//# sourceMappingURL=process-service.js.map