@nsshunt/stsrunnerframework 1.0.200 → 2.0.1

package/types/testing/testCase01.d.ts

@@ -1,21 +1,241 @@
-import { IRunnerInstance, IRunnerOptions, IRunner, WorkerInstance } from './../index';
+ 
+/**
+ * TestCase01
+ * ==========
+ *
+ * Concrete test runner implementation used to validate the runner framework.
+ *
+ * Purpose
+ * -------
+ * `TestCase01` is a synthetic/example runner that performs predictable,
+ * low-risk work so the surrounding framework can be tested.
+ *
+ * It is designed to exercise and demonstrate:
+ *
+ * - runner lifecycle methods
+ *   - start
+ *   - stop
+ *   - pause
+ *   - resume
+ *   - reset
+ *   - update
+ *   - complete
+ *   - terminate
+ * - telemetry generation and batching
+ * - log message generation
+ * - metric updates
+ * - active request tracking
+ * - duration measurement
+ * - delayed work simulation using `Sleep(...)`
+ *
+ * It does not perform real business work. Instead, it simulates work by:
+ *
+ * - updating telemetry counters
+ * - optionally sleeping for a configured duration
+ * - generating periodic messages
+ * - publishing telemetry using batching and timeout logic
+ *
+ * Architectural role
+ * ------------------
+ * This class is a concrete implementation of {@link IRunnerInstance}.
+ *
+ * It is hosted by a concrete worker-side execution host such as
+ * `WorkerTestCases`, which in turn derives from
+ * {@link AbstractRunnerExecutionWorker}.
+ *
+ * The framework uses this runner to validate that:
+ *
+ * - worker command routing works
+ * - runner execution loops work
+ * - telemetry publication works
+ * - runner lifecycle messages behave as expected
+ */
+import { IRunnerInstance, IRunnerOptions, IRunner } from './../index';
+import { AbstractRunnerExecutionWorker } from './../abstractRunnerExecutionWorker';
+/**
+ * Extended runner options used specifically by `TestCase01`.
+ *
+ * In addition to standard framework runner options, this test case supports:
+ *
+ * - `sleepDuration`
+ * - `logMessageMod`
+ * - `colourIndex`
+ *
+ * These fields allow the test runner to simulate work and produce predictable
+ * telemetry/logging behaviour.
+ */
 export interface IRunnerOptionsEx extends IRunnerOptions {
+    /**
+     * Simulated work delay in milliseconds for each execution iteration.
+     *
+     * If greater than zero, the runner sleeps for this duration inside `ExecuteRunner()`.
+     * If zero, it yields immediately instead.
+     */
     sleepDuration: number;
+    /**
+     * Frequency for generating animated log messages.
+     *
+     * Example:
+     * - if `logMessageMod` is `5`, a generated log message is emitted every 5 requests.
+     */
     logMessageMod: number;
+    /**
+     * Placeholder/example option for colour selection.
+     *
+     * Currently present for test flexibility but not actively used in the logic shown here.
+     */
     colourIndex: number;
 }
+/**
+ * Concrete synthetic test runner implementation.
+ *
+ * This runner:
+ * - simulates work
+ * - updates telemetry counters
+ * - batches telemetry publishing
+ * - emits lifecycle log messages
+ */
 export declare class TestCase01 implements IRunnerInstance {
     #private;
-    constructor(workerInstance: WorkerInstance, runner: IRunner);
+    /**
+     * Construct a new synthetic test runner.
+     *
+     * @param runnerExecutionWorker Owning worker-side execution host.
+     * @param runner Live runner model/state for this test runner.
+     */
+    constructor(runnerExecutionWorker: AbstractRunnerExecutionWorker, runner: IRunner);
+    /**
+     * Yield immediately to the event loop/microtask queue.
+     *
+     * Used when the runner wants to behave asynchronously but does not need
+     * a real delay.
+     *
+     * @returns Resolved promise.
+     */
     SleepImmediate(): Promise<void>;
+    /**
+     * Execute one synthetic unit of work for this runner.
+     *
+     * Behaviour
+     * ---------
+     * - captures start time
+     * - reads extended runner options
+     * - updates telemetry counters/metrics
+     * - optionally generates log messages
+     * - optionally emits status/progress messages
+     * - simulates actual work using:
+     *   - `Sleep(options.sleepDuration)`, or
+     *   - immediate yield
+     * - decrements active request count
+     * - records duration
+     * - publishes telemetry using buffered publish logic
+     *
+     * Telemetry updates performed
+     * ---------------------------
+     * - `coreCount = 1`
+     * - `activeRequestCount++`
+     * - `requestCount++`
+     * - `velocity++`
+     * - `tx += 256000`
+     * - `rx += 6500000`
+     * - `duration = measured execution time`
+     *
+     * Notes
+     * -----
+     * - This method simulates real work rather than performing domain logic
+     * - It is intended to validate the framework's runner/telemetry lifecycle
+     * - After the awaited work delay, the actual framework runner state may have
+     *   changed externally, but this test implementation does not directly react here
+     *
+     * @returns `true` when the synthetic work cycle completes.
+     */
     ExecuteRunner: () => Promise<any>;
+    /**
+     * Handle framework "start" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     StartRunner: () => Promise<any>;
+    /**
+     * Handle framework "stop" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     StopRunner: () => Promise<any>;
+    /**
+     * Handle framework "terminate" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     TerminateRunner: () => Promise<any>;
+    /**
+     * Handle framework "completed" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a completion lifecycle message including current telemetry snapshot
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     Completed: () => Promise<any>;
+    /**
+     * Handle framework "pause" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     * - returns a descriptive diagnostic string
+     *
+     * @returns Diagnostic pause message.
+     */
     PauseRunner: () => Promise<any>;
+    /**
+     * Handle framework "resume" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     * - returns a descriptive diagnostic string
+     *
+     * @returns Diagnostic resume message.
+     */
     ResumeRunner: () => Promise<any>;
+    /**
+     * Handle framework "reset" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - resets `requestCount` to zero
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     ResetRunner: () => Promise<any>;
+    /**
+     * Handle framework "update" lifecycle event for this runner.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * Note:
+     * - this implementation does not directly apply option changes itself;
+     *   it simply acknowledges the lifecycle event for framework testing
+     *
+     * @returns `true`
+     */
     UpdateRunner: () => Promise<any>;
 }
 //# sourceMappingURL=testCase01.d.ts.map

package/types/testing/testCase01.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testCase01.d.ts","sourceRoot":"","sources":["../../src/testing/testCase01.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAqB,MAAM,YAAY,CAAA;AAcxG,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACpD,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;CACtB;AAED,qBAAa,UAAW,YAAW,eAAe;;gBASlC,cAAc,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO;IAmG3D,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B,aAAa,QAAa,OAAO,CAAC,GAAG,CAAC,CAqCrC;IASD,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAInC;IAED,UAAU,QAAa,OAAO,CAAC,GAAG,CAAC,CAIlC;IAED,eAAe,QAAa,OAAO,CAAC,GAAG,CAAC,CAIvC;IAED,SAAS,QAAa,OAAO,CAAC,GAAG,CAAC,CAIjC;IAED,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAKnC;IAED,YAAY,QAAa,OAAO,CAAC,GAAG,CAAC,CAIpC;IAED,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAKnC;IAED,YAAY,QAAa,OAAO,CAAC,GAAG,CAAC,CAIpC;CACJ"}
+{"version":3,"file":"testCase01.d.ts","sourceRoot":"","sources":["../../src/testing/testCase01.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AA0CnF;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACpD;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;GAQG;AACH,qBAAa,UAAW,YAAW,eAAe;;IAqD9C;;;;;OAKG;gBACS,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,EAAE,OAAO;IA0KjF;;;;;;;OAOG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAmCG;IACH,aAAa,QAAa,OAAO,CAAC,GAAG,CAAC,CA+CpC;IAeF;;;;;;;;OAQG;IACH,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAIlC;IAEF;;;;;;;;OAQG;IACH,UAAU,QAAa,OAAO,CAAC,GAAG,CAAC,CAIjC;IAEF;;;;;;;;OAQG;IACH,eAAe,QAAa,OAAO,CAAC,GAAG,CAAC,CAItC;IAEF;;;;;;;;OAQG;IACH,SAAS,QAAa,OAAO,CAAC,GAAG,CAAC,CAIhC;IAEF;;;;;;;;;OASG;IACH,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAIlC;IAEF;;;;;;;;;OASG;IACH,YAAY,QAAa,OAAO,CAAC,GAAG,CAAC,CAInC;IAEF;;;;;;;;;OASG;IACH,WAAW,QAAa,OAAO,CAAC,GAAG,CAAC,CAKlC;IAEF;;;;;;;;;;;;OAYG;IACH,YAAY,QAAa,OAAO,CAAC,GAAG,CAAC,CAInC;CACL"}

package/types/testing/testCase02.d.ts

@@ -1,21 +1,225 @@
-import { IRunnerInstance, IRunnerOptions, IRunner, WorkerInstance } from './../index';
+ 
+/**
+ * TestCase02
+ * ==========
+ *
+ * Second concrete example runner used to test and demonstrate the runner framework.
+ *
+ * Purpose
+ * -------
+ * `TestCase02` is a synthetic runner implementation very similar to `TestCase01`,
+ * but with slightly different behaviour and output style. It is intended to help
+ * validate that the framework can host multiple concrete runner types behind the
+ * same worker/runtime abstraction.
+ *
+ * This test runner is useful for exercising:
+ *
+ * - runner lifecycle callbacks
+ * - telemetry batching and publishing
+ * - execution timing/duration capture
+ * - log message generation
+ * - active request tracking
+ * - update/reset/pause/resume/terminate flows
+ * - multiple concrete test runner implementations in the same framework
+ *
+ * Key difference from TestCase01
+ * ------------------------------
+ * While structurally very similar to `TestCase01`, this runner also writes a
+ * per-iteration status message directly to `console.log(...)` during execution.
+ *
+ * That makes this class useful when you want:
+ *
+ * - visible console progress while testing
+ * - easier manual observation of iteration flow
+ * - a second runner implementation to verify type-based runner selection
+ *
+ * Architectural role
+ * ------------------
+ * `TestCase02` is a concrete implementation of {@link IRunnerInstance}.
+ *
+ * It is hosted by a worker-side execution host such as `WorkerTestCases`,
+ * which itself derives from {@link AbstractRunnerExecutionWorker}.
+ *
+ * Like `TestCase01`, this runner does not perform real business work. Instead,
+ * it simulates repeatable work and emits telemetry so the surrounding framework
+ * can be validated.
+ */
+import { IRunnerInstance, IRunnerOptions, IRunner } from './../index';
+import { AbstractRunnerExecutionWorker } from './../abstractRunnerExecutionWorker';
+/**
+ * Extended runner options used by `TestCase02`.
+ *
+ * In addition to the standard runner options, this test runner supports:
+ *
+ * - `sleepDuration`
+ * - `logMessageMod`
+ * - `colourIndex`
+ */
 export interface IRunnerOptionsEx extends IRunnerOptions {
+    /**
+     * Simulated work delay in milliseconds for each execution cycle.
+     */
     sleepDuration: number;
+    /**
+     * Frequency used for generated "Hello World" log messages.
+     *
+     * Example:
+     * - if set to `10`, an animated log message is generated every 10 requests.
+     */
     logMessageMod: number;
+    /**
+     * Placeholder/example option for colour selection.
+     *
+     * Present for testing/extensibility, though not directly used in the logic shown.
+     */
     colourIndex: number;
 }
+/**
+ * Concrete synthetic test runner implementation.
+ *
+ * This runner simulates work, updates telemetry, batches telemetry publishing,
+ * and writes both internal telemetry messages and visible console progress.
+ */
 export declare class TestCase02 implements IRunnerInstance {
     #private;
-    constructor(workerInstance: WorkerInstance, runner: IRunner);
+    /**
+     * Construct a new `TestCase02` runner.
+     *
+     * @param runnerExecutionWorker Owning worker-side execution host.
+     * @param runner Live runner model/state.
+     */
+    constructor(runnerExecutionWorker: AbstractRunnerExecutionWorker, runner: IRunner);
+    /**
+     * Yield immediately to the event loop/microtask queue.
+     *
+     * Used when asynchronous behaviour is desired but no real delay is needed.
+     *
+     * @returns Resolved promise.
+     */
     SleepImmediate(): Promise<void>;
+    /**
+     * Execute one synthetic unit of work for this runner.
+     *
+     * Behaviour
+     * ---------
+     * - captures start time
+     * - reads extended test options
+     * - updates runner telemetry
+     * - optionally generates animated telemetry messages
+     * - always generates a progress message for telemetry
+     * - always writes a progress message to `console.log(...)`
+     * - simulates work with either:
+     *   - `Sleep(options.sleepDuration)`, or
+     *   - immediate yield
+     * - decrements active request count
+     * - calculates and stores execution duration
+     * - performs buffered telemetry publication
+     *
+     * Telemetry fields updated
+     * ------------------------
+     * - `coreCount = 1`
+     * - `activeRequestCount++`
+     * - `requestCount++`
+     * - `velocity++`
+     * - `tx += 256000`
+     * - `rx += 6500000`
+     * - `duration = measured elapsed time`
+     *
+     * Additional visible behaviour
+     * ----------------------------
+     * Unlike `TestCase01`, this implementation always writes a progress message
+     * directly to the process/browser console using `console.log(...)`.
+     *
+     * This makes it more useful for manually watching test progress while the
+     * framework is running.
+     *
+     * @returns `true` when the simulated work cycle completes.
+     */
     ExecuteRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "start" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     StartRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "stop" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     StopRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "terminate" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     TerminateRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "completed" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a completion message including the current telemetry snapshot
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     Completed: () => Promise<boolean>;
+    /**
+     * Handle framework "pause" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     PauseRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "resume" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     ResumeRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "reset" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - resets `requestCount` to zero
+     * - forces immediate telemetry publication
+     *
+     * @returns `true`
+     */
     ResetRunner: () => Promise<boolean>;
+    /**
+     * Handle framework "update" lifecycle event.
+     *
+     * Behaviour:
+     * - writes a lifecycle message
+     * - forces immediate telemetry publication
+     *
+     * Note:
+     * - this implementation acknowledges the update event but does not apply
+     *   custom update logic itself
+     *
+     * @returns `true`
+     */
     UpdateRunner: () => Promise<boolean>;
 }
 //# sourceMappingURL=testCase02.d.ts.map

package/types/testing/testCase02.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testCase02.d.ts","sourceRoot":"","sources":["../../src/testing/testCase02.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,cAAc,EAAqB,MAAM,YAAY,CAAA;AAcxG,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACpD,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAA;IACrB,WAAW,EAAE,MAAM,CAAA;CACtB;AAED,qBAAa,UAAW,YAAW,eAAe;;gBASlC,cAAc,EAAE,cAAc,EAAE,MAAM,EAAE,OAAO;IAmG3D,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B,aAAa,QAAa,OAAO,CAAC,OAAO,CAAC,CAwCzC;IASD,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAIvC;IAED,UAAU,QAAa,OAAO,CAAC,OAAO,CAAC,CAItC;IAED,eAAe,QAAa,OAAO,CAAC,OAAO,CAAC,CAI3C;IAED,SAAS,QAAa,OAAO,CAAC,OAAO,CAAC,CAIrC;IAED,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAIvC;IAED,YAAY,QAAa,OAAO,CAAC,OAAO,CAAC,CAIxC;IAED,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAKvC;IAED,YAAY,QAAa,OAAO,CAAC,OAAO,CAAC,CAIxC;CACJ"}
+{"version":3,"file":"testCase02.d.ts","sourceRoot":"","sources":["../../src/testing/testCase02.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AACtE,OAAO,EAAE,6BAA6B,EAAE,MAAM,oCAAoC,CAAC;AAyCnF;;;;;;;;GAQG;AACH,MAAM,WAAW,gBAAiB,SAAQ,cAAc;IACpD;;OAEG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;;OAKG;IACH,aAAa,EAAE,MAAM,CAAC;IAEtB;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,eAAe;;IAmD9C;;;;;OAKG;gBACS,qBAAqB,EAAE,6BAA6B,EAAE,MAAM,EAAE,OAAO;IA8JjF;;;;;;OAMG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IAM/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,aAAa,QAAa,OAAO,CAAC,OAAO,CAAC,CAyDxC;IAeF;;;;;;;;OAQG;IACH,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAItC;IAEF;;;;;;;;OAQG;IACH,UAAU,QAAa,OAAO,CAAC,OAAO,CAAC,CAIrC;IAEF;;;;;;;;OAQG;IACH,eAAe,QAAa,OAAO,CAAC,OAAO,CAAC,CAI1C;IAEF;;;;;;;;OAQG;IACH,SAAS,QAAa,OAAO,CAAC,OAAO,CAAC,CAIpC;IAEF;;;;;;;;OAQG;IACH,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAItC;IAEF;;;;;;;;OAQG;IACH,YAAY,QAAa,OAAO,CAAC,OAAO,CAAC,CAIvC;IAEF;;;;;;;;;OASG;IACH,WAAW,QAAa,OAAO,CAAC,OAAO,CAAC,CAKtC;IAEF;;;;;;;;;;;;OAYG;IACH,YAAY,QAAa,OAAO,CAAC,OAAO,CAAC,CAIvC;CACL"}

package/types/testing/wmwokerProcess.test.d.ts

@@ -1,2 +1,3 @@
+ 
 export {};
 //# sourceMappingURL=wmwokerProcess.test.d.ts.map

package/types/testing/wmwokerProcess2.test.d.ts

@@ -1,2 +1,3 @@
+ 
 export {};
 //# sourceMappingURL=wmwokerProcess2.test.d.ts.map

package/types/workerCommandCoordinator.d.ts

@@ -0,0 +1,152 @@
+ 
+/**
+ * WorkerCommandCoordinator
+ * ------------------------
+ * Orchestration component responsible for executing commands across:
+ *
+ * 1. one or more workers
+ * 2. one or more runners within a specific worker
+ *
+ * This class does not own workers or runners directly. Instead, it coordinates
+ * command execution using the shared {@link WorkerRegistry}.
+ *
+ * Responsibilities:
+ * - locate target workers from the registry
+ * - fan out a command to multiple workers
+ * - fan out a command to multiple runners within a worker
+ * - aggregate per-runner results into worker-level result structures
+ * - centralise error handling and logging for command orchestration
+ *
+ * Typical commands handled:
+ * - Start
+ * - Stop
+ * - Pause
+ * - Resume
+ * - Execute
+ * - Reset
+ * - Terminate
+ * - Update
+ *
+ * Notes:
+ * - Worker-level commands ultimately invoke matching methods on {@link IWorkerEx}
+ * - Runner-level commands ultimately invoke matching methods on {@link IRunnerEx}
+ * - `Update` is handled specially because it requires `runnerOptions`
+ * - An empty `workerIds` or `runnerIds` array is treated as "all"
+ *   for the relevant scope, depending on how the registry/worker methods behave
+ */
+import { IRunnerOptions, IExecuteWorkerActionResult, IExecuteRunnerActionResult } from './commonTypes';
+import { WorkerRegistry } from './workerRegistry';
+import { ISTSLogger } from '@nsshunt/stsutils';
+/**
+ * Constructor options for {@link WorkerCommandCoordinator}.
+ */
+export interface IWorkerCommandCoordinator {
+    /**
+     * Logger used for diagnostics and error reporting.
+     */
+    logger: ISTSLogger;
+    /**
+     * Shared live worker registry used to resolve workers and runners.
+     */
+    workerRegistry: WorkerRegistry;
+    /**
+     * Id of the top-level worker manager that owns the workers being coordinated.
+     *
+     * This value is included in worker-level result payloads so callers can
+     * trace results back to the manager instance that executed them.
+     */
+    workerManagerId: string;
+}
+/**
+ * Central coordinator for worker-level and runner-level command execution.
+ *
+ * This class is intentionally orchestration-only:
+ * - it does not store workers itself
+ * - it does not mutate registry structure directly
+ * - it does not implement worker/runner business logic
+ *
+ * Instead, it:
+ * - resolves workers/runners from the registry
+ * - dispatches command calls to them
+ * - collects/normalises the resulting responses
+ */
+export declare class WorkerCommandCoordinator {
+    /**
+     * Immutable configuration and dependencies for this coordinator.
+     */
+    private readonly options;
+    /**
+     * Construct a new worker command coordinator.
+     *
+     * @param options Logger, worker registry, and worker manager id.
+     */
+    constructor(options: IWorkerCommandCoordinator);
+    /**
+     * Execute the same command against one or more workers.
+     *
+     * Behaviour:
+     * - resolves the target workers from the registry using `workerIds`
+     * - invokes the specified command on each worker
+     * - waits for all worker command calls to complete
+     * - wraps each worker's per-runner result list in an `IExecuteWorkerActionResult`
+     * - returns a result entry per worker
+     *
+     * Command semantics:
+     * - For non-`Update` commands, the worker method is invoked with no arguments
+     * - For `Update`, the worker method is invoked with `runnerOptions`
+     *
+     * Worker selection:
+     * - The underlying registry method `GetWorkersEx(workerIds)` determines how
+     *   worker filtering works
+     * - In the current design, an empty `workerIds` array typically means "all workers"
+     *
+     * Returned structure:
+     * Each result includes:
+     * - `workerManagerId`
+     * - `workerId`
+     * - `executeRunnerActionResults`
+     *
+     * Error handling:
+     * - Errors are logged
+     * - The method returns an empty array on failure rather than throwing
+     *
+     * @param workerIds List of target worker ids. Use `[]` to target all workers, if supported by the registry.
+     * @param command Worker command to execute.
+     * @param runnerOptions Optional runner option updates, only used for `Update`.
+     * @returns Array of worker-level aggregated results.
+     */
+    ExecuteWorkerCommands: (workerIds: string[], command: "Start" | "Stop" | "Pause" | "Resume" | "Execute" | "Reset" | "Terminate" | "Update", runnerOptions?: Partial<IRunnerOptions>) => Promise<IExecuteWorkerActionResult[]>;
+    /**
+     * Execute the same command against one or more runners within a single worker.
+     *
+     * Behaviour:
+     * - resolves the target worker from the registry
+     * - if `runnerIds` is empty, executes the worker-level command directly
+     *   (which applies to all runners in that worker)
+     * - otherwise resolves the specific target runners from the worker
+     * - invokes the specified command on each target runner
+     * - waits for all runner command calls to complete
+     * - returns a flat array of per-runner results
+     *
+     * Command semantics:
+     * - For non-`Update` commands, the runner method is invoked with no arguments
+     * - For `Update`, the runner method is invoked with `runnerOptions`
+     *
+     * Runner selection:
+     * - If `runnerIds.length === 0`, the worker itself is asked to execute the command
+     *   across all its runners
+     * - Otherwise only runners matching the supplied ids are targeted
+     *
+     * Error handling:
+     * - Errors are logged
+     * - The method returns an empty array on failure rather than throwing
+     *
+     * @param workerId Id of the worker containing the target runners.
+     * @param runnerIds List of target runner ids. Use `[]` to target all runners in the worker.
+     * @param command Runner command to execute.
+     * @param runnerOptions Optional runner option updates, only used for `Update`.
+     * @returns Array of per-runner action results.
+     */
+    ExecuteRunnerCommands: (workerId: string, runnerIds: string[], command: "Start" | "Stop" | "Pause" | "Resume" | "Execute" | "Reset" | "Terminate" | "Update", runnerOptions?: Partial<IRunnerOptions>) => Promise<IExecuteRunnerActionResult[]>;
+}
+//# sourceMappingURL=workerCommandCoordinator.d.ts.map

package/types/workerCommandCoordinator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workerCommandCoordinator.d.ts","sourceRoot":"","sources":["../src/workerCommandCoordinator.ts"],"names":[],"mappings":";AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAGH,OAAO,EACH,cAAc,EACd,0BAA0B,EAC1B,0BAA0B,EAC7B,MAAM,eAAe,CAAC;AAKvB,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACtC;;OAEG;IACH,MAAM,EAAE,UAAU,CAAC;IAEnB;;OAEG;IACH,cAAc,EAAE,cAAc,CAAC;IAE/B;;;;;OAKG;IACH,eAAe,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,wBAAwB;IACjC;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA4B;IAEpD;;;;OAIG;gBACS,OAAO,EAAE,yBAAyB;IAI9C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACI,qBAAqB,GACxB,WAAW,MAAM,EAAE,EACnB,SAAS,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,QAAQ,EAC7F,gBAAgB,OAAO,CAAC,cAAc,CAAC,KACxC,OAAO,CAAC,0BAA0B,EAAE,CAAC,CA2DtC;IAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH,qBAAqB,GACjB,UAAU,MAAM,EAChB,WAAW,MAAM,EAAE,EACnB,SAAS,OAAO,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,QAAQ,EAC7F,gBAAgB,OAAO,CAAC,cAAc,CAAC,KACxC,OAAO,CAAC,0BAA0B,EAAE,CAAC,CA2EtC;CACL"}