@nsshunt/ststestrunner 1.1.13 → 1.1.15

package/dist/ststestrunner.mjs

@@ -57,24 +57,25 @@ var TestCaseFhirBase = class {
 				return new https.Agent(options);
 			}
 		});
+		const agentManager = createAgentManager({
+			agentOptions: {
+				keepAlive: true,
+				maxFreeSockets: 10,
+				maxSockets: 10,
+				maxTotalSockets: 20,
+				timeout: 6e4,
+				rejectUnauthorized: false
+			},
+			httpAgentFactory(options) {
+				return new http.Agent(options);
+			},
+			httpsAgentFactory(options) {
+				return new https.Agent(options);
+			}
+		});
 		this.authUtilsNode = new AuthUtilsNode({
 			logger: defaultLogger,
-			agentManager: createAgentManager({
-				agentOptions: {
-					keepAlive: true,
-					maxFreeSockets: 10,
-					maxSockets: 10,
-					maxTotalSockets: 20,
-					timeout: 6e4,
-					rejectUnauthorized: false
-				},
-				httpAgentFactory(options) {
-					return new http.Agent(options);
-				},
-				httpsAgentFactory(options) {
-					return new https.Agent(options);
-				}
-			})
+			agentManager
 		});
 	}
 	get runnerExecutionWorker() {
@@ -1334,11 +1335,837 @@ var TestCaseFhir10 = class extends TestCaseFhirQueryBase {
 	};
 };
 //#endregion
+//#region src/libmodule/testCase01.ts
+/**
+* Concrete synthetic test runner implementation.
+*
+* This runner:
+* - simulates work
+* - updates telemetry counters
+* - batches telemetry publishing
+* - emits lifecycle log messages
+*/
+var TestCase01 = class {
+	/**
+	* The live serialisable runner model/state owned by this test runner.
+	*
+	* This object is mutated as telemetry and execution progress change.
+	*/
+	#runner;
+	/**
+	* Owning worker-side execution host.
+	*
+	* Used primarily to publish telemetry back to the manager by runner id.
+	*/
+	#runnerExecutionWorker;
+	/**
+	* Per-runner state used for animated/indented generated log messages.
+	*/
+	#logMessageDataSet = {};
+	/**
+	* Timeout handle used to perform delayed telemetry publication.
+	*
+	* This supports the "publish on timeout if buffer threshold is not reached"
+	* batching strategy.
+	*/
+	#publishTelemetryTimeout = null;
+	/**
+	* Counter of buffered telemetry publication events since the last publish.
+	*
+	* When this reaches `#maxBufferSize`, telemetry is published immediately.
+	*/
+	#publishTelemetryCount = 0;
+	/**
+	* Maximum number of telemetry buffer events allowed before forcing a publish.
+	*
+	* This is intended to remain lower than the logging/instrument buffer size
+	* used elsewhere in the observability stack.
+	*/
+	#maxBufferSize = 50;
+	/**
+	* Maximum time in milliseconds to wait before publishing buffered telemetry.
+	*
+	* Telemetry publish strategy:
+	* - whichever happens first wins:
+	*   - max buffer count reached
+	*   - timeout reached
+	*/
+	#publishTelemetryTimeoutVal = 1e3;
+	/**
+	* 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, runner) {
+		this.#runnerExecutionWorker = runnerExecutionWorker;
+		this.#runner = runner;
+	}
+	/**
+	* Internal low-level log sink used by this test case.
+	*
+	* Currently disabled/commented out to avoid noisy console output during tests.
+	*
+	* @param message Message to output.
+	*/
+	#LogMessage = (message) => {};
+	/**
+	* Generate an animated indented log message for the runner.
+	*
+	* Behaviour:
+	* - lazily initialises per-runner indentation state
+	* - creates a message with varying indentation
+	* - appends that message to runner telemetry messages
+	* - updates indentation direction when bounds are reached
+	*
+	* Indentation behaviour:
+	* - increases from 0 upward
+	* - reverses direction after passing 20
+	* - reverses again when returning to 0
+	*
+	* This exists purely to generate visually changing test log output.
+	*
+	* @param runner Runner whose message should be generated.
+	* @param iteration Current runner iteration number.
+	*/
+	#GenLogMessage = (runner, iteration) => {
+		if (!this.#logMessageDataSet[runner.id]) this.#logMessageDataSet[runner.id] = {
+			adder: 1,
+			indent: 0
+		};
+		const logMessageData = this.#logMessageDataSet[runner.id];
+		const message = `${" ".repeat(logMessageData.indent)} [${runner.id}] >> Hello World << ${iteration}`;
+		this.#LogMessage(message);
+		runner.instrumentData.message.push(message);
+		logMessageData.indent += logMessageData.adder;
+		if (logMessageData.indent > 20) logMessageData.adder = -1;
+		else if (logMessageData.indent === 0) logMessageData.adder = 1;
+	};
+	/**
+	* Ensure a timeout-based telemetry publish is scheduled.
+	*
+	* Behaviour:
+	* - if no publish timeout exists, creates one
+	* - when the timeout fires:
+	*   - publishes telemetry
+	*   - resets buffered publish count
+	*   - clears the timeout handle
+	*
+	* In Node.js the timer is `unref()`'d so it does not keep the process alive.
+	*/
+	#SetupTimeout = async () => {
+		if (!this.#publishTelemetryTimeout) {
+			this.#publishTelemetryTimeout = setTimeout(async () => {
+				this.#LogMessage(chalk.yellow(`   PublishTelemetryData - Normal Behaviour (**** TIMEOUT ****) `));
+				await this.#PublishTelemetryData();
+				this.#publishTelemetryCount = 0;
+				this.#publishTelemetryTimeout = null;
+			}, this.#publishTelemetryTimeoutVal);
+			if (isNode) this.#publishTelemetryTimeout.unref();
+		}
+	};
+	/**
+	* Publish the current runner telemetry snapshot immediately.
+	*
+	* Behaviour:
+	* - asks the owning worker execution host to post telemetry for this runner
+	* - writes a separator line to the local log sink
+	* - resets selected per-cycle telemetry fields ready for the next publish window
+	* - yields immediately before returning
+	*
+	* Telemetry fields reset after publish:
+	* - `velocity`
+	* - `message`
+	* - `tx`
+	* - `rx`
+	*
+	* Notes:
+	* - not all telemetry fields are reset here; only those intended to behave
+	*   as per-publish-window accumulators
+	*/
+	#PublishTelemetryData = async () => {
+		this.#runnerExecutionWorker.PostTelemetryById(this.#runner.id);
+		this.#LogMessage(chalk.red(`------------------------------------------------------------------------------------------------------------`));
+		this.#runner.instrumentData.velocity = 0;
+		this.#runner.instrumentData.message = [];
+		this.#runner.instrumentData.tx = 0;
+		this.#runner.instrumentData.rx = 0;
+		await this.SleepImmediate();
+	};
+	/**
+	* Force an immediate telemetry publish regardless of current buffer count.
+	*
+	* Used for important lifecycle transitions such as:
+	* - start
+	* - stop
+	* - pause
+	* - resume
+	* - reset
+	* - terminate
+	* - complete
+	*/
+	#ForcePublishTelemetryData = async () => {
+		this.#LogMessage(chalk.magenta(`   **** FORCED PUBLISH **** `));
+		await this.#PublishTelemetryData();
+	};
+	/**
+	* Buffer and publish telemetry using a mixed threshold/timeout strategy.
+	*
+	* Behaviour:
+	* - increments the buffered telemetry count
+	* - if the count reaches `#maxBufferSize`:
+	*   - clears any pending timeout
+	*   - publishes immediately
+	*   - resets the buffered count
+	* - otherwise ensures a timeout is scheduled
+	*
+	* This creates a "whichever happens first" batching model:
+	* - count threshold
+	* - timeout threshold
+	*/
+	#PublishTelemetry = async () => {
+		this.#publishTelemetryCount++;
+		if (this.#publishTelemetryCount % this.#maxBufferSize === 0) {
+			this.#LogMessage(chalk.cyan(`   **** MAX COUNT REACHED **** `));
+			this.#publishTelemetryCount = 0;
+			if (this.#publishTelemetryTimeout) {
+				clearTimeout(this.#publishTelemetryTimeout);
+				this.#publishTelemetryTimeout = null;
+			}
+			await this.#PublishTelemetryData();
+		}
+		if (!this.#publishTelemetryTimeout) this.#SetupTimeout();
+	};
+	/**
+	* 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() {
+		return new Promise((resolve, reject) => {
+			resolve();
+		});
+	}
+	/**
+	* 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 = async () => {
+		const start = performance.now();
+		const options = this.#runner.options;
+		this.#runner.instrumentData.coreCount = 1;
+		this.#runner.instrumentData.activeRequestCount++;
+		this.#runner.instrumentData.requestCount++;
+		this.#runner.instrumentData.velocity++;
+		this.#runner.instrumentData.tx += 256e3;
+		this.#runner.instrumentData.rx += 65e5;
+		if (this.#runner.instrumentData.requestCount % options.logMessageMod === 0) this.#GenLogMessage(this.#runner, this.#runner.iteration);
+		if (this.#runner.instrumentData.requestCount % 1 === 0) {
+			const message = `Worker: [${this.#runner.asyncRunnerContext.threadId}], Runner: [${this.#runner.asyncRunnerContext.id}] has completed: [${this.#runner.instrumentData.requestCount}] iterations of max: [${options.executionProfile.iterations}]`;
+			this.#LogMessage(message);
+			this.#runner.instrumentData.message = [message];
+		}
+		/**
+		* Simulate actual work.
+		*
+		* In real runner implementations this is where domain-specific work would occur:
+		* - REST calls
+		* - DB access
+		* - browser automation
+		* - file processing
+		* etc.
+		*/
+		if (options.sleepDuration > 0) await Sleep(options.sleepDuration);
+		else await this.SleepImmediate();
+		this.#runner.instrumentData.activeRequestCount--;
+		const diff = performance.now() - start;
+		this.#runner.instrumentData.duration = diff;
+		await this.#PublishTelemetry();
+		return true;
+	};
+	/**
+	* Write a grey-coloured lifecycle message into the runner telemetry message buffer
+	* and publish telemetry using normal buffered publish logic.
+	*
+	* @param message Lifecycle/status message to emit.
+	*/
+	#OutputLogMessage = async (message) => {
+		const messageOutput = chalk.grey(message);
+		this.#LogMessage(messageOutput);
+		this.#runner.instrumentData.message.push(messageOutput);
+		await this.#PublishTelemetry();
+	};
+	/**
+	* Handle framework "start" lifecycle event for this runner.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	StartRunner = async () => {
+		await this.#OutputLogMessage(`StartRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "stop" lifecycle event for this runner.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	StopRunner = async () => {
+		await this.#OutputLogMessage(`StopRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "terminate" lifecycle event for this runner.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	TerminateRunner = async () => {
+		await this.#OutputLogMessage(`TerminateRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* 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 = async () => {
+		await this.#OutputLogMessage(`Completed [${this.#runner.id}] [${JSON.stringify(this.#runner.instrumentData)}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* 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 = async () => {
+		await this.#OutputLogMessage(`PauseRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return `I have been paused at iteration: [${this.#runner.iteration}]  Date: [${/* @__PURE__ */ new Date()}]  Performance: [${performance.now()}]`;
+	};
+	/**
+	* 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 = async () => {
+		await this.#OutputLogMessage(`ResumeRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return `I have been resumed at iteration: [${this.#runner.iteration}]  Date: [${/* @__PURE__ */ new Date()}]  Performance: [${performance.now()}]`;
+	};
+	/**
+	* Handle framework "reset" lifecycle event for this runner.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - resets `requestCount` to zero
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	ResetRunner = async () => {
+		await this.#OutputLogMessage(`ResetRunner [${this.#runner.id}]`);
+		this.#runner.instrumentData.requestCount = 0;
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* 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 = async () => {
+		await this.#OutputLogMessage(`UpdateOptions [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+};
+//#endregion
+//#region src/libmodule/testCase02.ts
+/**
+* Concrete synthetic test runner implementation.
+*
+* This runner simulates work, updates telemetry, batches telemetry publishing,
+* and writes both internal telemetry messages and visible console progress.
+*/
+var TestCase02 = class {
+	/**
+	* Live serialisable runner model/state for this test runner.
+	*
+	* This object is mutated as execution and telemetry progress.
+	*/
+	#runner;
+	/**
+	* Owning worker-side execution host.
+	*
+	* Used primarily to publish telemetry for this runner back to the manager.
+	*/
+	#runnerExecutionWorker;
+	/**
+	* Per-runner animated log message state.
+	*/
+	#logMessageDataSet = {};
+	/**
+	* Timeout handle used for delayed telemetry publication.
+	*
+	* Supports timeout-based flush behaviour when the publish count threshold
+	* has not yet been reached.
+	*/
+	#publishTelemetryTimeout = null;
+	/**
+	* Count of buffered telemetry-publish requests since the last flush.
+	*/
+	#publishTelemetryCount = 0;
+	/**
+	* Maximum buffered publish count before telemetry is flushed immediately.
+	*
+	* This should remain lower than the maximum observability/logging buffer size
+	* used elsewhere in the framework.
+	*/
+	#maxBufferSize = 50;
+	/**
+	* Maximum time in milliseconds to wait before flushing telemetry.
+	*
+	* Publish strategy:
+	* - whichever happens first:
+	*   - max buffer size reached
+	*   - timeout reached
+	*/
+	#publishTelemetryTimeoutVal = 1e3;
+	/**
+	* Construct a new `TestCase02` runner.
+	*
+	* @param runnerExecutionWorker Owning worker-side execution host.
+	* @param runner Live runner model/state.
+	*/
+	constructor(runnerExecutionWorker, runner) {
+		this.#runnerExecutionWorker = runnerExecutionWorker;
+		this.#runner = runner;
+	}
+	/**
+	* Internal low-level log sink.
+	*
+	* Currently disabled/commented out to avoid noisy console output during normal testing.
+	* The class still uses `console.log(...)` directly in `ExecuteRunner()` for visible progress.
+	*
+	* @param message Message to output.
+	*/
+	#LogMessage = (message) => {};
+	/**
+	* Generate an animated indented "Hello World" style log message.
+	*
+	* Behaviour:
+	* - initialises per-runner indentation state if needed
+	* - builds a message with variable indentation
+	* - appends the message to the runner telemetry message buffer
+	* - updates indentation direction when bounds are reached
+	*
+	* Indentation pattern:
+	* - grows from 0 upward
+	* - reverses after exceeding 20
+	* - reverses again when returning to 0
+	*
+	* @param runner Runner whose message should be generated.
+	* @param iteration Current iteration number.
+	*/
+	#GenLogMessage = (runner, iteration) => {
+		if (!this.#logMessageDataSet[runner.id]) this.#logMessageDataSet[runner.id] = {
+			adder: 1,
+			indent: 0
+		};
+		const logMessageData = this.#logMessageDataSet[runner.id];
+		const message = `${" ".repeat(logMessageData.indent)} [${runner.id}] >> Hello World << ${iteration}`;
+		this.#LogMessage(message);
+		runner.instrumentData.message.push(message);
+		logMessageData.indent += logMessageData.adder;
+		if (logMessageData.indent > 20) logMessageData.adder = -1;
+		else if (logMessageData.indent === 0) logMessageData.adder = 1;
+	};
+	/**
+	* Schedule a timeout-based telemetry flush if one is not already active.
+	*
+	* Behaviour:
+	* - creates a timeout only when no current timeout exists
+	* - when the timeout fires:
+	*   - telemetry is published
+	*   - buffered publish count is reset
+	*   - timeout handle is cleared
+	*
+	* In Node.js, the timer is `unref()`'d so it does not keep the process alive.
+	*/
+	#SetupTimeout = async () => {
+		if (!this.#publishTelemetryTimeout) {
+			this.#publishTelemetryTimeout = setTimeout(async () => {
+				this.#LogMessage(chalk.yellow(`   PublishTelemetryData - Normal Behaviour (**** TIMEOUT ****) `));
+				await this.#PublishTelemetryData();
+				this.#publishTelemetryCount = 0;
+				this.#publishTelemetryTimeout = null;
+			}, this.#publishTelemetryTimeoutVal);
+			if (isNode) this.#publishTelemetryTimeout.unref();
+		}
+	};
+	/**
+	* Publish the current telemetry snapshot immediately.
+	*
+	* Behaviour:
+	* - asks the owning execution worker to post telemetry for this runner
+	* - writes a separator line to the local test log sink
+	* - resets transient per-publish telemetry fields
+	* - yields immediately before returning
+	*
+	* Reset after publish:
+	* - `velocity`
+	* - `message`
+	* - `tx`
+	* - `rx`
+	*/
+	#PublishTelemetryData = async () => {
+		this.#runnerExecutionWorker.PostTelemetryById(this.#runner.id);
+		this.#LogMessage(chalk.red(`------------------------------------------------------------------------------------------------------------`));
+		this.#runner.instrumentData.velocity = 0;
+		this.#runner.instrumentData.message = [];
+		this.#runner.instrumentData.tx = 0;
+		this.#runner.instrumentData.rx = 0;
+		await this.SleepImmediate();
+	};
+	/**
+	* Force an immediate telemetry publication.
+	*
+	* Used for lifecycle transitions where immediate visibility is desirable.
+	*/
+	#ForcePublishTelemetryData = async () => {
+		this.#LogMessage(chalk.magenta(`   **** FORCED PUBLISH **** `));
+		await this.#PublishTelemetryData();
+	};
+	/**
+	* Buffer telemetry and publish using a threshold-or-timeout strategy.
+	*
+	* Behaviour:
+	* - increments buffered telemetry count
+	* - when the count reaches `#maxBufferSize`:
+	*   - clears any pending timeout
+	*   - immediately publishes telemetry
+	*   - resets buffered count
+	* - otherwise ensures a timeout flush is scheduled
+	*
+	* This gives a "first trigger wins" strategy:
+	* - count threshold reached
+	* - timeout reached
+	*/
+	#PublishTelemetry = async () => {
+		this.#publishTelemetryCount++;
+		if (this.#publishTelemetryCount % this.#maxBufferSize === 0) {
+			this.#LogMessage(chalk.cyan(`   **** MAX COUNT REACHED **** `));
+			this.#publishTelemetryCount = 0;
+			if (this.#publishTelemetryTimeout) {
+				clearTimeout(this.#publishTelemetryTimeout);
+				this.#publishTelemetryTimeout = null;
+			}
+			await this.#PublishTelemetryData();
+		}
+		if (!this.#publishTelemetryTimeout) this.#SetupTimeout();
+	};
+	/**
+	* Yield immediately to the event loop/microtask queue.
+	*
+	* Used when asynchronous behaviour is desired but no real delay is needed.
+	*
+	* @returns Resolved promise.
+	*/
+	SleepImmediate() {
+		return new Promise((resolve, reject) => {
+			resolve();
+		});
+	}
+	/**
+	* 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 = async () => {
+		const start = performance.now();
+		const options = this.#runner.options;
+		this.#runner.instrumentData.coreCount = 1;
+		this.#runner.instrumentData.activeRequestCount++;
+		this.#runner.instrumentData.requestCount++;
+		this.#runner.instrumentData.velocity++;
+		this.#runner.instrumentData.tx += 256e3;
+		this.#runner.instrumentData.rx += 65e5;
+		if (this.#runner.instrumentData.requestCount % options.logMessageMod === 0) this.#GenLogMessage(this.#runner, this.#runner.iteration);
+		if (this.#runner.instrumentData.requestCount % 1 === 0) {
+			const message = `Worker: [${this.#runner.asyncRunnerContext.threadId}], Runner: [${this.#runner.asyncRunnerContext.id}] has completed: [${this.#runner.instrumentData.requestCount}] iterations of max: [${options.executionProfile.iterations}]`;
+			this.#LogMessage(message);
+			this.#runner.instrumentData.message = [message];
+		}
+		/**
+		* Visible console output for manual observation/debugging.
+		*
+		* This is the main behavioural difference from `TestCase01`.
+		*/
+		const message = `Worker: [${this.#runner.asyncRunnerContext.threadId}], Runner: [${this.#runner.asyncRunnerContext.id}] has completed: [${this.#runner.instrumentData.requestCount}] iterations of max: [${options.executionProfile.iterations}]`;
+		console.log(message);
+		/**
+		* Simulate actual work.
+		*
+		* In a real runner implementation this would be replaced with
+		* domain-specific work such as:
+		* - REST/API calls
+		* - browser interactions
+		* - DB operations
+		* - file processing
+		* etc.
+		*/
+		if (options.sleepDuration > 0) await Sleep(options.sleepDuration);
+		else await this.SleepImmediate();
+		this.#runner.instrumentData.activeRequestCount--;
+		const diff = performance.now() - start;
+		this.#runner.instrumentData.duration = diff;
+		await this.#PublishTelemetry();
+		return true;
+	};
+	/**
+	* Write a grey-coloured lifecycle message into the runner telemetry message buffer
+	* and publish telemetry using normal buffered publish rules.
+	*
+	* @param message Lifecycle/status message to emit.
+	*/
+	#OutputLogMessage = async (message) => {
+		const messageOutput = chalk.grey(message);
+		this.#LogMessage(messageOutput);
+		this.#runner.instrumentData.message.push(messageOutput);
+		await this.#PublishTelemetry();
+	};
+	/**
+	* Handle framework "start" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	StartRunner = async () => {
+		await this.#OutputLogMessage(`StartRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "stop" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	StopRunner = async () => {
+		await this.#OutputLogMessage(`StopRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "terminate" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	TerminateRunner = async () => {
+		await this.#OutputLogMessage(`TerminateRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "completed" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a completion message including the current telemetry snapshot
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	Completed = async () => {
+		await this.#OutputLogMessage(`Completed [${this.#runner.id}] [${JSON.stringify(this.#runner.instrumentData)}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "pause" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	PauseRunner = async () => {
+		await this.#OutputLogMessage(`PauseRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "resume" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	ResumeRunner = async () => {
+		await this.#OutputLogMessage(`ResumeRunner [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* Handle framework "reset" lifecycle event.
+	*
+	* Behaviour:
+	* - writes a lifecycle message
+	* - resets `requestCount` to zero
+	* - forces immediate telemetry publication
+	*
+	* @returns `true`
+	*/
+	ResetRunner = async () => {
+		await this.#OutputLogMessage(`ResetRunner [${this.#runner.id}]`);
+		this.#runner.instrumentData.requestCount = 0;
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+	/**
+	* 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 = async () => {
+		await this.#OutputLogMessage(`UpdateOptions [${this.#runner.id}]`);
+		await this.#ForcePublishTelemetryData();
+		return true;
+	};
+};
+//#endregion
 //#region src/libmodule/asyncRunnerFactory.ts
 var AsyncRunnerFactory = class {
 	static CreateAsyncRunner = async (runnerExecutionWorker, testRunnerTelemetryPayload) => {
 		const { runner } = testRunnerTelemetryPayload;
 		switch (runner.options.testType) {
+			case "TestCase01": return new TestCase01(runnerExecutionWorker, runner);
+			case "TestCase02": return new TestCase02(runnerExecutionWorker, runner);
 			case "TestCaseFhir01": return new TestCaseFhir01(runnerExecutionWorker, runner);
 			case "TestCaseFhir02": return new TestCaseFhir02(runnerExecutionWorker, runner);
 			case "TestCaseFhir03": return new TestCaseFhir03(runnerExecutionWorker, runner);