@mcp-abap-adt/adt-clients 37.0.0 → 37.2.0

package/README.md

@@ -157,9 +157,9 @@ npm install @mcp-abap-adt/adt-clients
    - Typed execution API based on `IExecutor`
    - Executors:
      - `getClassExecutor()` for `classrun`
-     - `getClassTestRunner()` for a class's ABAP Unit tests: `run`, `getStatus`, `getResult`
-     - `getProgramTestRunner()` for a report's ABAP Unit tests, in its source or its includes
-     - `getFunctionGroupTestRunner()` / `getFunctionModuleTestRunner()` for a function group's tests, or the ones exercising one module
+     - `getClassTestRunner()` for a class's ABAP Unit tests: `run`, `getStatus`, `getResult` (asynchronous, the default), or `runSync` (synchronous)
+     - `getProgramTestRunner()` for a report's ABAP Unit tests, in its source or its includes — `run` (asynchronous, the default) or `runSync`
+     - `getFunctionGroupTestRunner()` / `getFunctionModuleTestRunner()` for a function group's tests, or a module's — `run` (asynchronous, the default) or `runSync`
      - `getProgramExecutor()` for `programrun` (on-premise systems)
    - Methods: `run`, `runWithProfiler`, and trace scheduling (`scheduleTrace`, `listRequests`, `getRequestsByUri`, `listObjectTypes`, `listProcessTypes`)
    - Each executor factory takes an optional result set, like the runtime client's
@@ -440,13 +440,65 @@ const result = await runner.getResult(runId, { analyse: analyseUnitTest });
 `{ containerClass, testClass }`. On a legacy system the runner's `run` answers
 the finished result, and `getStatus`/`getResult` refuse without a request.
 
+**The synchronous runner, `runSync`.** `run` starts a run on
+`/sap/bc/adt/abapunit/runs`, which is then polled; that stays the default.
+`runSync` is the other runner ADT has — one `POST /sap/bc/adt/abapunit/testruns`
+answering the finished `aunit:runResult` — chosen explicitly by the caller.
+Some systems have only this one (an on-prem S/4HANA 2023, SAP_BASIS 758, was
+measured without `/abapunit/runs`); whether a system has `/runs` is in its
+discovery, and reading that is the caller's — the library picks no runner by
+release or by discovery.
+
+```typescript
+const result = await runner.runSync('ZCL_UNDER_TEST', { analyse: analyseUnitTest });
+```
+
+Its answer is read by the runner's `result` strategy, the one `getResult` uses:
+on the measured systems (on premise and ABAP Cloud, 2026-10-22) both runners
+answer the same document — `aunit:runResult` in `http://www.sap.com/adt/aunit`
+— with the same methods and alerts. Two differences: the endpoint addresses
+whole classes, so `{ containerClass, testClass }` targets run each distinct
+container whole; and `title` and `context` are not sent. Scope, risk levels and
+durations are, with `run`'s defaults. On a legacy system `runSync` is the
+request `run` already sends there, read by `result`.
+
 A report's tests are local classes in its source or in an include it pulls in —
 written through `getProgram().update()` or `getInclude().update()` — and run
 through `executor.getProgramTestRunner().run(programName)`, with the same
 `getStatus`/`getResult`. A function group's are written in an include of the
 group (`getFunctionInclude()`) and run through `getFunctionGroupTestRunner()`
 for the whole group or `getFunctionModuleTestRunner()` for one module. Below
-7.50 these three runners refuse without a request.
+7.50 these three runners refuse without a request, `runSync` included.
+
+All three have `runSync` as well — the same `/abapunit/testruns` request as a
+class's, naming the object by its URI, read by `result` and judged by
+`options.analyse`:
+
+```typescript
+await executor.getProgramTestRunner().runSync('ZREPORT', { analyse: analyseUnitTest });
+await executor.getFunctionGroupTestRunner().runSync('ZGROUP', { analyse: analyseUnitTest });
+await executor
+  .getFunctionModuleTestRunner()
+  .runSync({ functionGroupName: 'ZGROUP', functionModuleName: 'Z_MODULE' }, { analyse: analyseUnitTest });
+```
+
+Their run configuration always carries `<options>` (scope, risk levels and
+durations, with `run`'s defaults). Measured on premise (SAP_BASIS 816,
+2026-10-23): with it, a report (test class in its own source or in an include),
+a function group and a function module each ran the same tests with the same
+alerts as `run`; without it the endpoint answered `200` with an empty
+`aunit:runResult`. Name the report, not the include: an include's own URI ran
+nothing, its tests run through the report.
+
+**A module's `runSync` runs its whole group's tests.** The module's URI lies
+under its group's, so the target names both. On the measured system it ran
+every test of the group — a test class that calls no module included — and so
+did the run of a module that no test calls; the result names the group
+(`FUGR/F`). `run` (`FUNC`) did the same there. The library filters nothing: a
+caller who wants one module's tests reads them out of the result. With an ABAP
+Doc test relation (`"! @testing FUNC:<module>`) on a test class, the default
+scope answered the group's tests as a preview (`isForeign="true"`, nothing
+executed) and `scope: { foreignTests: true }` ran them.
 
 **AdtUtils read type safety:**
 `readObjectMetadata` and `readObjectSource` accept strict object type unions to prevent invalid inputs like `view:ZOBJ`.

package/dist/core/class/index.d.ts

@@ -6,6 +6,6 @@ export { AdtLocalDefinitions, type ILocalDefinitionsConfig, } from './AdtLocalDe
 export { AdtLocalMacros, type ILocalMacrosConfig } from './AdtLocalMacros';
 export { AdtLocalTestClass, type ILocalTestClassConfig, } from './AdtLocalTestClass';
 export { AdtLocalTypes, type ILocalTypesConfig } from './AdtLocalTypes';
-export { getClassUnitTestResult, getClassUnitTestStatus, IClassUnitTestDefinition, IClassUnitTestRunOptions, startClassUnitTestRun, startClassUnitTestRunByObject, } from './run';
+export { getClassUnitTestResult, getClassUnitTestStatus, IClassUnitTestDefinition, IClassUnitTestRunOptions, startClassUnitTestRun, startClassUnitTestRunByObject, startClassUnitTestRunSync, } from './run';
 export * from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/class/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/class/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,GAC9B,MAAM,OAAO,CAAC;AACf,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/class/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EACL,mBAAmB,EACnB,KAAK,uBAAuB,GAC7B,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,cAAc,EAAE,KAAK,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC3E,OAAO,EACL,iBAAiB,EACjB,KAAK,qBAAqB,GAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,aAAa,EAAE,KAAK,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACxE,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,wBAAwB,EACxB,wBAAwB,EACxB,qBAAqB,EACrB,6BAA6B,EAC7B,yBAAyB,GAC1B,MAAM,OAAO,CAAC;AACf,cAAc,SAAS,CAAC"}

package/dist/core/class/index.js

@@ -17,7 +17,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.startClassUnitTestRunByObject = exports.startClassUnitTestRun = exports.getClassUnitTestStatus = exports.getClassUnitTestResult = exports.AdtLocalTypes = exports.AdtLocalTestClass = exports.AdtLocalMacros = exports.AdtLocalDefinitions = exports.AdtClass = void 0;
+exports.startClassUnitTestRunSync = exports.startClassUnitTestRunByObject = exports.startClassUnitTestRun = exports.getClassUnitTestStatus = exports.getClassUnitTestResult = exports.AdtLocalTypes = exports.AdtLocalTestClass = exports.AdtLocalMacros = exports.AdtLocalDefinitions = exports.AdtClass = void 0;
 var AdtClass_1 = require("./AdtClass");
 Object.defineProperty(exports, "AdtClass", { enumerable: true, get: function () { return AdtClass_1.AdtClass; } });
 var AdtLocalDefinitions_1 = require("./AdtLocalDefinitions");
@@ -33,4 +33,5 @@ Object.defineProperty(exports, "getClassUnitTestResult", { enumerable: true, get
 Object.defineProperty(exports, "getClassUnitTestStatus", { enumerable: true, get: function () { return run_1.getClassUnitTestStatus; } });
 Object.defineProperty(exports, "startClassUnitTestRun", { enumerable: true, get: function () { return run_1.startClassUnitTestRun; } });
 Object.defineProperty(exports, "startClassUnitTestRunByObject", { enumerable: true, get: function () { return run_1.startClassUnitTestRunByObject; } });
+Object.defineProperty(exports, "startClassUnitTestRunSync", { enumerable: true, get: function () { return run_1.startClassUnitTestRunSync; } });
 __exportStar(require("./types"), exports);

package/dist/core/class/run.d.ts

@@ -61,4 +61,15 @@ export declare const getClassUnitTestResult: typeof getUnitTestRunResult;
  * container runs without the caller naming one.
  */
 export declare function startClassUnitTestRunByObject(connection: IAbapConnection, className: string, options?: IClassUnitTestRunOptions): Promise<IAdtWireResponse>;
+/**
+ * Run the ABAP Unit tests of whole classes and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll. The
+ * request is `startUnitTestRunSync` (`core/shared/abapUnit`), given each
+ * class's URI; see there for the format and what was measured.
+ *
+ * The regular runner's `runSync` and the legacy runner's `run` both send it.
+ * `options` absent sends no `<options>` element — the body the legacy runner
+ * has always sent, unchanged.
+ */
+export declare function startClassUnitTestRunSync(connection: IAbapConnection, classNames: string[], options?: IClassUnitTestRunOptions): Promise<IAdtWireResponse>;
 //# sourceMappingURL=run.d.ts.map

package/dist/core/class/run.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/core/class/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,OAAc,EACxB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AAOD,YAAY,EACV,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAErB,MAAM,oBAAoB,CAAC;AAE5B,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,wBAAwB,EAAE,EACjC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA6C3B;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAM3B"}
+{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../../src/core/class/run.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAKjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAsB,QAAQ,CAC5B,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,OAAc,EACxB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,YAAY,GACtB,OAAO,CAAC,gBAAgB,CAAC,CAoB3B;AAOD,YAAY,EACV,wBAAwB,EACxB,wBAAwB,GACzB,MAAM,8BAA8B,CAAC;AAMtC,OAAO,KAAK,EACV,wBAAwB,EACxB,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EAGrB,MAAM,oBAAoB,CAAC;AAE5B,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,wBAAwB,EAAE,EACjC,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA6C3B;AAED,mFAAmF;AACnF,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,6BAAuB,CAAC;AAE3D;;;;GAIG;AACH,wBAAsB,6BAA6B,CACjD,UAAU,EAAE,eAAe,EAC3B,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAM3B;AAMD;;;;;;;;;GASG;AACH,wBAAsB,yBAAyB,CAC7C,UAAU,EAAE,eAAe,EAC3B,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CAM3B"}

package/dist/core/class/run.js

@@ -7,6 +7,8 @@ exports.getClassUnitTestResult = exports.getClassUnitTestStatus = void 0;
 exports.runClass = runClass;
 exports.startClassUnitTestRun = startClassUnitTestRun;
 exports.startClassUnitTestRunByObject = startClassUnitTestRunByObject;
+exports.startClassUnitTestRunSync = startClassUnitTestRunSync;
+const objects_1 = require("../../endpoints/objects");
 const passport_1 = require("../../runtime/debugger/passport");
 const xml_1 = require("../../utils/xml");
 /**
@@ -126,3 +128,19 @@ exports.getClassUnitTestResult = abapUnit_1.getUnitTestRunResult;
 async function startClassUnitTestRunByObject(connection, className, options) {
     return (0, abapUnit_1.startUnitTestRunByObject)(connection, { name: className, type: 'CLAS' }, options);
 }
+// =============================================================================
+// The synchronous runner: /abapunit/testruns
+// =============================================================================
+/**
+ * Run the ABAP Unit tests of whole classes and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll. The
+ * request is `startUnitTestRunSync` (`core/shared/abapUnit`), given each
+ * class's URI; see there for the format and what was measured.
+ *
+ * The regular runner's `runSync` and the legacy runner's `run` both send it.
+ * `options` absent sends no `<options>` element — the body the legacy runner
+ * has always sent, unchanged.
+ */
+async function startClassUnitTestRunSync(connection, classNames, options) {
+    return (0, abapUnit_1.startUnitTestRunSync)(connection, classNames.map((name) => objects_1.CLASS.uri(name)), options);
+}

package/dist/core/shared/abapUnit.d.ts

@@ -29,4 +29,50 @@ export declare function getUnitTestRunResult(connection: IAbapConnection, runId:
     withNavigationUris?: boolean;
     format?: 'abapunit' | 'junit';
 }): Promise<IAdtWireResponse>;
+/**
+ * Run the ABAP Unit tests of whole objects and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll. The
+ * objects are named by their ADT URIs: a class, a report, a function group, a
+ * function module.
+ *
+ * The one implementation of this endpoint: every runner's `runSync`, and the
+ * legacy class runner's `run`, send it.
+ *
+ * **Measured:** synchronous on a modern and a legacy on-prem system, over HTTP
+ * and over RFC — `<aunit:runResult>` in the POST's answer, no `Location` — and
+ * the typed and `application/xml` bodies byte-identical; the legacy system
+ * ignores a typed `Accept` and answers `application/xml` either way. Advertised
+ * (2026-10-22) by an on-prem system and an ABAP Cloud system alike, beside
+ * `/abapunit/runs`; and on an on-prem S/4HANA 2023 that has no `/runs` at all
+ * (fr0ster/mcp-abap-adt#286).
+ *
+ * **`<options>` decides whether anything runs for a report or a function
+ * group.** Measured on premise (SAP_BASIS 816, 2026-10-23): with `<options>`, a
+ * report (test class in its own source or in an include it pulls in), a
+ * function group and a function module each ran the same tests with the same
+ * alerts as `/abapunit/runs`; the same body without `<options>` answered `200`
+ * with an empty `<aunit:runResult/>` for all four. An include's own URI
+ * answered empty even with `<options>` — its tests run through the report. So
+ * every runner but the legacy class runner sends `<options>`.
+ *
+ * **Reading the result: `kind` carries the distinction, `severity` does not.**
+ * A failed assertion and an uncaught exception both come back
+ * `severity="critical"`, so a parser classifying on severity reports a short
+ * dump as a failed test. `kind` separates them: `failedAssertion`,
+ * `exception`, `noTestClasses`.
+ *
+ * The format differs from `/runs`:
+ * - root `aunit:runConfiguration` in `http://www.sap.com/adt/aunit` (not
+ *   `aunit:run` in `http://www.sap.com/adt/api/aunit`);
+ * - objects by URI in `adtcore:objectReferences` — so a run covers whole
+ *   objects: the format has no way to name one test class inside its
+ *   container;
+ * - `application/xml` for `Content-Type` and `Accept`.
+ *
+ * `options` absent sends no `<options>` element — the body the legacy class
+ * runner has always sent, unchanged. Given (`{}` included), the scope, risk
+ * levels and durations go in `<options>` with the same defaults `/runs` gets;
+ * `title` and `context` have no place in this format and are not sent.
+ */
+export declare function startUnitTestRunSync(connection: IAbapConnection, objectUris: string[], options?: IClassUnitTestRunOptions): Promise<IAdtWireResponse>;
 //# sourceMappingURL=abapUnit.d.ts.map

package/dist/core/shared/abapUnit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abapUnit.d.ts","sourceRoot":"","sources":["../../../src/core/shared/abapUnit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAajD,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wDAAwD;AACxD,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA2C3B;AAED,kBAAkB;AAClB,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,MAAM,EACb,eAAe,GAAE,OAAc,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAU3B;AAED,wCAAwC;AACxC,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAA;CAAE,GACxE,OAAO,CAAC,gBAAgB,CAAC,CAkB3B"}
+{"version":3,"file":"abapUnit.d.ts","sourceRoot":"","sources":["../../../src/core/shared/abapUnit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,8BAA8B,CAAC;AAC7E,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EACjB,MAAM,yCAAyC,CAAC;AAajD,6DAA6D;AAC7D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAC;IACb,wDAAwD;IACxD,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wDAAwD;AACxD,wBAAsB,wBAAwB,CAC5C,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,kBAAkB,EAC1B,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA2C3B;AAED,kBAAkB;AAClB,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,MAAM,EACb,eAAe,GAAE,OAAc,GAC9B,OAAO,CAAC,gBAAgB,CAAC,CAU3B;AAED,wCAAwC;AACxC,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE;IAAE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,UAAU,GAAG,OAAO,CAAA;CAAE,GACxE,OAAO,CAAC,gBAAgB,CAAC,CAkB3B;AASD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAsB,oBAAoB,CACxC,UAAU,EAAE,eAAe,EAC3B,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,wBAAwB,GACjC,OAAO,CAAC,gBAAgB,CAAC,CA8B3B"}

package/dist/core/shared/abapUnit.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.startUnitTestRunByObject = startUnitTestRunByObject;
 exports.getUnitTestRunStatus = getUnitTestRunStatus;
 exports.getUnitTestRunResult = getUnitTestRunResult;
+exports.startUnitTestRunSync = startUnitTestRunSync;
 const contentTypes_1 = require("../../constants/contentTypes");
 const xml_1 = require("../../utils/xml");
 function boolAttr(value, fallback) {
@@ -95,3 +96,100 @@ async function getUnitTestRunResult(connection, runId, options) {
         },
     });
 }
+// =============================================================================
+// The synchronous runner: /abapunit/testruns
+// =============================================================================
+const CT_TESTRUNS = 'application/xml';
+const ACCEPT_TESTRUNS = 'application/xml';
+/**
+ * Run the ABAP Unit tests of whole objects and answer the finished result —
+ * `POST /sap/bc/adt/abapunit/testruns`, one request, no run to poll. The
+ * objects are named by their ADT URIs: a class, a report, a function group, a
+ * function module.
+ *
+ * The one implementation of this endpoint: every runner's `runSync`, and the
+ * legacy class runner's `run`, send it.
+ *
+ * **Measured:** synchronous on a modern and a legacy on-prem system, over HTTP
+ * and over RFC — `<aunit:runResult>` in the POST's answer, no `Location` — and
+ * the typed and `application/xml` bodies byte-identical; the legacy system
+ * ignores a typed `Accept` and answers `application/xml` either way. Advertised
+ * (2026-10-22) by an on-prem system and an ABAP Cloud system alike, beside
+ * `/abapunit/runs`; and on an on-prem S/4HANA 2023 that has no `/runs` at all
+ * (fr0ster/mcp-abap-adt#286).
+ *
+ * **`<options>` decides whether anything runs for a report or a function
+ * group.** Measured on premise (SAP_BASIS 816, 2026-10-23): with `<options>`, a
+ * report (test class in its own source or in an include it pulls in), a
+ * function group and a function module each ran the same tests with the same
+ * alerts as `/abapunit/runs`; the same body without `<options>` answered `200`
+ * with an empty `<aunit:runResult/>` for all four. An include's own URI
+ * answered empty even with `<options>` — its tests run through the report. So
+ * every runner but the legacy class runner sends `<options>`.
+ *
+ * **Reading the result: `kind` carries the distinction, `severity` does not.**
+ * A failed assertion and an uncaught exception both come back
+ * `severity="critical"`, so a parser classifying on severity reports a short
+ * dump as a failed test. `kind` separates them: `failedAssertion`,
+ * `exception`, `noTestClasses`.
+ *
+ * The format differs from `/runs`:
+ * - root `aunit:runConfiguration` in `http://www.sap.com/adt/aunit` (not
+ *   `aunit:run` in `http://www.sap.com/adt/api/aunit`);
+ * - objects by URI in `adtcore:objectReferences` — so a run covers whole
+ *   objects: the format has no way to name one test class inside its
+ *   container;
+ * - `application/xml` for `Content-Type` and `Accept`.
+ *
+ * `options` absent sends no `<options>` element — the body the legacy class
+ * runner has always sent, unchanged. Given (`{}` included), the scope, risk
+ * levels and durations go in `<options>` with the same defaults `/runs` gets;
+ * `title` and `context` have no place in this format and are not sent.
+ */
+async function startUnitTestRunSync(connection, objectUris, options) {
+    const objectRefs = objectUris
+        .map((uri) => {
+        return `        <adtcore:objectReference adtcore:uri="${(0, xml_1.escapeXmlAttr)(uri)}"/>`;
+    })
+        .join('\n');
+    const xml = `<?xml version="1.0" encoding="UTF-8"?><aunit:runConfiguration xmlns:aunit="http://www.sap.com/adt/aunit">
+  <external>
+    <coverage active="false"/>
+  </external>
+${options ? testRunsOptions(options) : ''}  <adtcore:objectSets xmlns:adtcore="http://www.sap.com/adt/core">
+    <objectSet kind="inclusive">
+      <adtcore:objectReferences>
+${objectRefs}
+      </adtcore:objectReferences>
+    </objectSet>
+  </adtcore:objectSets>
+</aunit:runConfiguration>`;
+    return connection.makeAdtRequest({
+        url: '/sap/bc/adt/abapunit/testruns',
+        method: 'POST',
+        timeout: 0,
+        data: xml,
+        headers: {
+            'Content-Type': CT_TESTRUNS,
+            Accept: ACCEPT_TESTRUNS,
+        },
+    });
+}
+/**
+ * `<options>` of a `runConfiguration`, as Eclipse sends it. The scope's three
+ * flags are `testDeterminationStrategy`'s: own tests are `sameProgram`,
+ * foreign tests `assignedTests`, their preview `appendAssignedTestsPreview`.
+ */
+function testRunsOptions(options) {
+    const scope = options.scope ?? {};
+    const risk = options.riskLevel ?? {};
+    const duration = options.duration ?? {};
+    return `  <options>
+    <uriType value="semantic"/>
+    <testDeterminationStrategy sameProgram="${boolAttr(scope.ownTests, true)}" assignedTests="${boolAttr(scope.foreignTests, false)}" appendAssignedTestsPreview="${boolAttr(scope.addForeignTestsAsPreview, true)}"/>
+    <testRiskLevels harmless="${boolAttr(risk.harmless, true)}" dangerous="${boolAttr(risk.dangerous, true)}" critical="${boolAttr(risk.critical, true)}"/>
+    <testDurations short="${boolAttr(duration.short, true)}" medium="${boolAttr(duration.medium, true)}" long="${boolAttr(duration.long, true)}"/>
+    <withNavigationUri enabled="true"/>
+  </options>
+`;
+}

package/dist/executors/abapUnitRunner.d.ts

@@ -39,6 +39,15 @@ export declare abstract class AbapUnitRunner<R extends IAbapUnitRunnerResults> i
     constructor(connection: IAbapConnection, logger: ILogger | undefined, results: R);
     /** Start a run of every test class the one named object holds. */
     protected startByObject<E extends IAdtError>(name: string, type: string, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * Run the tests of whole objects, named by their ADT URIs, and answer the
+     * finished result: one POST to `/abapunit/testruns`. Always with
+     * `<options>` — without it a report's, a function group's and a function
+     * module's run answered an empty result (see `core/shared/abapUnit`). The
+     * answer is the result document, so it is read by `result`, the strategy
+     * `getResult` uses; `options.analyse` judges it.
+     */
+    protected startSync<E extends IAdtError>(objectUris: string[], options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
     /**
      * Poll a run. Takes the run it is about: nothing here remembers the last one
      * started, because ADT does not either — any holder of the id may ask.

package/dist/executors/abapUnitRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abapUnitRunner.d.ts","sourceRoot":"","sources":["../../src/executors/abapUnitRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAS9D,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACvC,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC1C,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;CAIF,CAAC;AAEnC,8BAAsB,cAAc,CAAC,CAAC,SAAS,sBAAsB,CACnE,YACE,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEvE,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IAC/C,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;gBAG5B,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,EAAE,CAAC;IAOZ,kEAAkE;IAClE,SAAS,CAAC,aAAa,CAAC,CAAC,SAAS,SAAS,EACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQjD;;;OAGG;IACG,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,KAAK,EAAE,MAAM,EACb,eAAe,GAAE,OAAO,GAAG,SAAgB,EAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IASpD,6CAA6C;IACvC,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAOrD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,EACpD,IAAI,EAAE,MAAM,GACX,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAMpB"}
+{"version":3,"file":"abapUnitRunner.d.ts","sourceRoot":"","sources":["../../src/executors/abapUnitRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EACxB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACvB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAU9D,gFAAgF;AAChF,MAAM,WAAW,sBAAsB;IACrC,mFAAmF;IACnF,QAAQ,CAAC,GAAG,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACvC,kCAAkC;IAClC,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IAC1C,qDAAqD;IACrD,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;CAC3C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB;;;;CAIF,CAAC;AAEnC,8BAAsB,cAAc,CAAC,CAAC,SAAS,sBAAsB,CACnE,YACE,mBAAmB,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEvE,SAAS,CAAC,QAAQ,CAAC,UAAU,EAAE,eAAe,CAAC;IAC/C,SAAS,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC;IACpC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC;gBAG5B,UAAU,EAAE,eAAe,EAC3B,MAAM,EAAE,OAAO,GAAG,SAAS,EAC3B,OAAO,EAAE,CAAC;IAOZ,kEAAkE;IAClE,SAAS,CAAC,aAAa,CAAC,CAAC,SAAS,SAAS,EACzC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQjD;;;;;;;OAOG;IACH,SAAS,CAAC,SAAS,CAAC,CAAC,SAAS,SAAS,EACrC,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAWpD;;;OAGG;IACG,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,KAAK,EAAE,MAAM,EACb,eAAe,GAAE,OAAO,GAAG,SAAgB,EAC3C,OAAO,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC9B,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IASpD,6CAA6C;IACvC,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC7C,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAOrD;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,EACpD,IAAI,EAAE,MAAM,GACX,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CAMpB"}

package/dist/executors/abapUnitRunner.js

@@ -41,6 +41,20 @@ class AbapUnitRunner {
     startByObject(name, type, options) {
         return (0, adtResponse_1.answering)(() => (0, abapUnit_1.startUnitTestRunByObject)(this.connection, { name, type }, options), this.results.run, options?.analyse);
     }
+    /**
+     * Run the tests of whole objects, named by their ADT URIs, and answer the
+     * finished result: one POST to `/abapunit/testruns`. Always with
+     * `<options>` — without it a report's, a function group's and a function
+     * module's run answered an empty result (see `core/shared/abapUnit`). The
+     * answer is the result document, so it is read by `result`, the strategy
+     * `getResult` uses; `options.analyse` judges it.
+     */
+    startSync(objectUris, options) {
+        // `runOptions` is an object even when the caller gave none, so the
+        // `<options>` element is always sent.
+        const { analyse, ...runOptions } = options ?? {};
+        return (0, adtResponse_1.answering)(() => (0, abapUnit_1.startUnitTestRunSync)(this.connection, objectUris, runOptions), this.results.result, analyse);
+    }
     /**
      * Poll a run. Takes the run it is about: nothing here remembers the last one
      * started, because ADT does not either — any holder of the id may ask.

package/dist/executors/class/ClassTestRunner.d.ts

@@ -27,7 +27,12 @@ import { AbapUnitRunner, type IAbapUnitRunnerResults } from '../abapUnitRunner';
  * whose every test class runs.
  */
 export type IClassTestRunTarget = IClassUnitTestDefinition[] | string;
-/** One strategy per distinct answer: starting a run, polling it, its result. */
+/** The distinct containers a target names: what `/testruns` addresses. */
+export declare function containersOf(target: IClassTestRunTarget): string[];
+/**
+ * One strategy per distinct answer: starting a run, polling it, its result.
+ * `runSync` answers the result document itself, so it is read by `result`.
+ */
 export type IClassTestRunnerResults = IAbapUnitRunnerResults;
 /** The shipped default: documents as they arrived. */
 export declare const classTestRunnerDocuments: {
@@ -49,5 +54,26 @@ export declare class ClassTestRunner<R extends IClassTestRunnerResults = typeof
      * read as a failure.
      */
     run<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * Run the tests and answer the finished result. One POST, to
+     * `/sap/bc/adt/abapunit/testruns` — the synchronous runner, beside the
+     * asynchronous `run` + `getStatus` + `getResult`, which stays the default.
+     *
+     * An explicit choice of the caller's: nothing here asks the system which
+     * runner it has. A system without `/abapunit/runs` (an on-prem S/4HANA 2023
+     * was measured with `/testruns` alone) needs this one; whether a system has
+     * it is in its discovery, which is the caller's to read.
+     *
+     * The answer is the `aunit:runResult` document, so it is read by this
+     * runner's `result` strategy — the one `getResult` uses — and a failing test
+     * is in it as an `alert`; whether that is a failure is `options.analyse`'s
+     * (`analyseUnitTest` from @mcp-abap-adt/adt-strategies reads it so).
+     *
+     * Differences from `run`: the endpoint addresses whole classes, so a target
+     * of test definitions runs each distinct container whole, and `title` and
+     * `context` are not sent; scope, risk levels and durations are, with the
+     * same defaults.
+     */
+    runSync<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
 }
 //# sourceMappingURL=ClassTestRunner.d.ts.map

package/dist/executors/class/ClassTestRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAG9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,GAAG,MAAM,CAAC;AAEtE,gFAAgF;AAChF,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,sDAAsD;AACtD,eAAO,MAAM,wBAAwB;;;;CAA0B,CAAC;AAEhE,qBAAa,eAAe,CACxB,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CAErE,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CACV,mBAAmB,EACnB,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EACpB,wBAAwB,CACzB;gBAGD,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAA4C;IAKvD;;;;;;;;;;OAUG;IACG,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAUlD"}
+{"version":3,"file":"ClassTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACxB,wBAAwB,EACxB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAM9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAC5B,MAAM,mBAAmB,CAAC;AAE3B;;;GAGG;AACH,MAAM,MAAM,mBAAmB,GAAG,wBAAwB,EAAE,GAAG,MAAM,CAAC;AAEtE,0EAA0E;AAC1E,wBAAgB,YAAY,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,EAAE,CAIlE;AAED;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,sBAAsB,CAAC;AAE7D,sDAAsD;AACtD,eAAO,MAAM,wBAAwB;;;;CAA0B,CAAC;AAEhE,qBAAa,eAAe,CACxB,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CAErE,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CACV,mBAAmB,EACnB,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EACpB,wBAAwB,CACzB;gBAGD,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAA4C;IAKvD;;;;;;;;;;OAUG;IACG,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAWjD;;;;;;;;;;;;;;;;;;;OAmBG;IACG,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC3C,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAarD"}

package/dist/executors/class/ClassTestRunner.js

@@ -21,9 +21,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassTestRunner = exports.classTestRunnerDocuments = void 0;
+exports.containersOf = containersOf;
 const run_1 = require("../../core/class/run");
 const adtResponse_1 = require("../../utils/adtResponse");
 const abapUnitRunner_1 = require("../abapUnitRunner");
+/** The distinct containers a target names: what `/testruns` addresses. */
+function containersOf(target) {
+    return typeof target === 'string'
+        ? [target]
+        : [...new Set(target.map((test) => test.containerClass))];
+}
 /** The shipped default: documents as they arrived. */
 exports.classTestRunnerDocuments = abapUnitRunner_1.abapUnitRunnerDocuments;
 class ClassTestRunner extends abapUnitRunner_1.AbapUnitRunner {
@@ -49,5 +56,29 @@ class ClassTestRunner extends abapUnitRunner_1.AbapUnitRunner {
         }
         return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRun)(this.connection, target, options), this.results.run, options?.analyse);
     }
+    /**
+     * Run the tests and answer the finished result. One POST, to
+     * `/sap/bc/adt/abapunit/testruns` — the synchronous runner, beside the
+     * asynchronous `run` + `getStatus` + `getResult`, which stays the default.
+     *
+     * An explicit choice of the caller's: nothing here asks the system which
+     * runner it has. A system without `/abapunit/runs` (an on-prem S/4HANA 2023
+     * was measured with `/testruns` alone) needs this one; whether a system has
+     * it is in its discovery, which is the caller's to read.
+     *
+     * The answer is the `aunit:runResult` document, so it is read by this
+     * runner's `result` strategy — the one `getResult` uses — and a failing test
+     * is in it as an `alert`; whether that is a failure is `options.analyse`'s
+     * (`analyseUnitTest` from @mcp-abap-adt/adt-strategies reads it so).
+     *
+     * Differences from `run`: the endpoint addresses whole classes, so a target
+     * of test definitions runs each distinct container whole, and `title` and
+     * `context` are not sent; scope, risk levels and durations are, with the
+     * same defaults.
+     */
+    async runSync(target, options) {
+        const { analyse, ...runOptions } = options ?? {};
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, containersOf(target), runOptions), this.results.result, analyse);
+    }
 }
 exports.ClassTestRunner = ClassTestRunner;

package/dist/executors/class/ClassTestRunnerLegacy.d.ts

@@ -21,6 +21,12 @@ export declare class ClassTestRunnerLegacy<R extends IClassTestRunnerResults = t
      * result document itself, not an id.
      */
     run<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * The same request as `run` — on a legacy system `run` is already the
+     * synchronous one — answered through the `result` strategy, as the regular
+     * runner's `runSync` is.
+     */
+    runSync<E extends IAdtError = IAdtError>(target: IClassTestRunTarget, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
     /**
      * Refused without a request: a legacy system finishes a run before it
      * answers and exposes no run to poll. `run`'s own answer is the result.

package/dist/executors/class/ClassTestRunnerLegacy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClassTestRunnerLegacy.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunnerLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,EAC7B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,qBAAqB,CAChC,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CACnE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC1B;;;;;OAKG;IACY,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAChD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAYjD;;;OAGG;IACY,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IASD,0EAA0E;IAC3D,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAQF"}
+{"version":3,"file":"ClassTestRunnerLegacy.d.ts","sourceRoot":"","sources":["../../../src/executors/class/ClassTestRunnerLegacy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,wBAAwB,EAEzB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EACL,eAAe,EACf,KAAK,wBAAwB,EAE7B,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EACzB,MAAM,mBAAmB,CAAC;AAE3B,qBAAa,qBAAqB,CAChC,CAAC,SAAS,uBAAuB,GAAG,OAAO,wBAAwB,CACnE,SAAQ,eAAe,CAAC,CAAC,CAAC;IAC1B;;;;;OAKG;IACY,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAChD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAUjD;;;;OAIG;IACY,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACpD,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAQpD;;;OAGG;IACY,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IASD,0EAA0E;IAC3D,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAQF"}

package/dist/executors/class/ClassTestRunnerLegacy.js

@@ -15,7 +15,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassTestRunnerLegacy = void 0;
 const interfaces_adt_1 = require("@mcp-abap-adt/interfaces-adt");
-const runLegacy_1 = require("../../core/class/runLegacy");
+const run_1 = require("../../core/class/run");
 const adtResponse_1 = require("../../utils/adtResponse");
 const ClassTestRunner_1 = require("./ClassTestRunner");
 class ClassTestRunnerLegacy extends ClassTestRunner_1.ClassTestRunner {
@@ -26,10 +26,17 @@ class ClassTestRunnerLegacy extends ClassTestRunner_1.ClassTestRunner {
      * result document itself, not an id.
      */
     async run(target, options) {
-        const classNames = typeof target === 'string'
-            ? [target]
-            : [...new Set(target.map((test) => test.containerClass))];
-        return (0, adtResponse_1.answering)(() => (0, runLegacy_1.startClassUnitTestRunLegacy)(this.connection, classNames), this.results.run, options?.analyse);
+        // No options: the body a legacy system has always been sent — the
+        // `<options>` element `runSync` sends is unmeasured there.
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, (0, ClassTestRunner_1.containersOf)(target)), this.results.run, options?.analyse);
+    }
+    /**
+     * The same request as `run` — on a legacy system `run` is already the
+     * synchronous one — answered through the `result` strategy, as the regular
+     * runner's `runSync` is.
+     */
+    async runSync(target, options) {
+        return (0, adtResponse_1.answering)(() => (0, run_1.startClassUnitTestRunSync)(this.connection, (0, ClassTestRunner_1.containersOf)(target)), this.results.result, options?.analyse);
     }
     /**
      * Refused without a request: a legacy system finishes a run before it

package/dist/executors/functionGroup/FunctionGroupTestRunner.d.ts

@@ -9,6 +9,11 @@
  * `osl:object type="FUGR"` ran all seven test methods of a group whose test
  * include covers two test classes. Running one module's tests only is
  * `FunctionModuleTestRunner`.
+ *
+ * Measured on premise (SAP_BASIS 816, 2026-10-23): `/abapunit/testruns` given
+ * the group's URI runs the same tests with the same alerts as `/runs` — with
+ * the Eclipse-style `<options>` only; without it, an empty result. `runSync`
+ * always sends `<options>`.
  */
 import type { IAdtAnalyseOptions, IAdtError, IAdtResponse, IAdtRunnable, IClassUnitTestRunOptions } from '@mcp-abap-adt/interfaces-adt';
 import type { IAbapConnection } from '@mcp-abap-adt/interfaces-adt-connection';
@@ -24,13 +29,32 @@ export declare class FunctionGroupTestRunner<R extends IFunctionGroupTestRunnerR
     constructor(connection: IAbapConnection, logger?: ILogger, results?: R);
     /** Run every test class of the group. One POST. */
     run<E extends IAdtError = IAdtError>(functionGroupName: string, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    /**
+     * Run every test class of the group and answer the finished result. One
+     * POST, to `/sap/bc/adt/abapunit/testruns` — the synchronous runner, beside
+     * the asynchronous `run` + `getStatus` + `getResult`, which stays the
+     * default.
+     *
+     * An explicit choice of the caller's: nothing here asks the system which
+     * runner it has. The group is named by its URI and the run configuration
+     * always carries `<options>` (scope, risk levels and durations, with `run`'s
+     * defaults) — without it the endpoint answered an empty result for a group
+     * with tests. `title` and `context` are not sent.
+     *
+     * The answer is the `aunit:runResult` document, read by this runner's
+     * `result` strategy; whether a failing test is a failure is
+     * `options.analyse`'s.
+     */
+    runSync<E extends IAdtError = IAdtError>(functionGroupName: string, options?: IClassUnitTestRunOptions & IAdtAnalyseOptions<E>): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
 }
 /**
  * Below 7.50: refused without a request, as a report's run is — the legacy
- * endpoint has not been measured to find a group's tests.
+ * endpoint has not been measured to find a group's tests, with `<options>` or
+ * without. `runSync` is refused the same way.
  */
 export declare class FunctionGroupTestRunnerLegacy<R extends IFunctionGroupTestRunnerResults = typeof functionGroupTestRunnerDocuments> extends FunctionGroupTestRunner<R> {
     run<E extends IAdtError = IAdtError>(): Promise<IAdtResponse<ReturnType<R['run']>, E>>;
+    runSync<E extends IAdtError = IAdtError>(): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
     getStatus<E extends IAdtError = IAdtError>(): Promise<IAdtResponse<ReturnType<R['status']>, E>>;
     getResult<E extends IAdtError = IAdtError>(): Promise<IAdtResponse<ReturnType<R['result']>, E>>;
 }

package/dist/executors/functionGroup/FunctionGroupTestRunner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FunctionGroupTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/functionGroup/FunctionGroupTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAC9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAE5B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,+BAA+B,GAAG,sBAAsB,CAAC;AACrE,eAAO,MAAM,gCAAgC;;;;CAA0B,CAAC;AAExE,qBAAa,uBAAuB,CAChC,CAAC,SACC,+BAA+B,GAAG,OAAO,gCAAgC,CAE7E,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,wBAAwB,CAAC;gBAGpE,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAAoD;IAK/D,mDAAmD;IAC7C,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,iBAAiB,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAGlD;AAED;;;GAGG;AACH,qBAAa,6BAA6B,CACxC,CAAC,SACC,+BAA+B,GAAG,OAAO,gCAAgC,CAC3E,SAAQ,uBAAuB,CAAC,CAAC,CAAC;IACnB,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAC5D,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CACtC;IAIc,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IAIc,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAGF"}
+{"version":3,"file":"FunctionGroupTestRunner.d.ts","sourceRoot":"","sources":["../../../src/executors/functionGroup/FunctionGroupTestRunner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EACV,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,wBAAwB,EACzB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,gCAAgC,CAAC;AAE9D,OAAO,EACL,cAAc,EAEd,KAAK,sBAAsB,EAE5B,MAAM,mBAAmB,CAAC;AAE3B,MAAM,MAAM,+BAA+B,GAAG,sBAAsB,CAAC;AACrE,eAAO,MAAM,gCAAgC;;;;CAA0B,CAAC;AAExE,qBAAa,uBAAuB,CAChC,CAAC,SACC,+BAA+B,GAAG,OAAO,gCAAgC,CAE7E,SAAQ,cAAc,CAAC,CAAC,CACxB,YACE,YAAY,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,wBAAwB,CAAC;gBAGpE,UAAU,EAAE,eAAe,EAC3B,MAAM,CAAC,EAAE,OAAO,EAEhB,OAAO,GAAE,CAAoD;IAK/D,mDAAmD;IAC7C,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EACvC,iBAAiB,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAIjD;;;;;;;;;;;;;;;OAeG;IACG,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,EAC3C,iBAAiB,EAAE,MAAM,EACzB,OAAO,CAAC,EAAE,wBAAwB,GAAG,kBAAkB,CAAC,CAAC,CAAC,GACzD,OAAO,CAAC,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CAGrD;AAED;;;;GAIG;AACH,qBAAa,6BAA6B,CACxC,CAAC,SACC,+BAA+B,GAAG,OAAO,gCAAgC,CAC3E,SAAQ,uBAAuB,CAAC,CAAC,CAAC;IACnB,GAAG,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAC5D,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CACtC;IAIc,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAChE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IAIc,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;IAIc,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,SAAS,KAAK,OAAO,CAClE,YAAY,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CACzC;CAGF"}