@oisincoveney/pipeline 2.8.4 → 2.9.0

package/dist/run-control/commands.js

@@ -0,0 +1,340 @@
+import { listRunsEffect, readRunEffect, updateNodeStatusEffect, updateRunStatusEffect } from "./store.js";
+import { Effect } from "effect";
+import { join, relative, sep } from "node:path";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { setTimeout } from "node:timers/promises";
+//#region src/run-control/commands.ts
+const RUNS_DIRECTORY = ".pipeline/runs";
+const MANIFEST_FILE = "manifest.json";
+const NODES_DIRECTORY = "nodes";
+const WATCH_INTERVAL_MS = 1e3;
+const PATH_SEPARATOR_RE = /[\\/]/;
+const ACTIVE_RUN_STATUSES = new Set([
+	"queued",
+	"starting",
+	"running",
+	"stalled"
+]);
+const ACTIVE_NODE_STATUSES = new Set([
+	"queued",
+	"starting",
+	"running",
+	"stalled"
+]);
+function registerRunControlCommands(program) {
+	program.command("runs").description("List known Moka runs, newest first").action(async () => {
+		await Effect.runPromise(printRunsEffect(workspaceRoot()));
+	});
+	program.command("status").description("Show run-control status for a Moka run").argument("[run-id]", "run id to inspect; defaults to latest active run").option("--watch", "poll status until the selected run is no longer active").option("--json", "print machine-readable run status").action(async (runId, flags) => {
+		await Effect.runPromise(printStatusEffect({
+			flags,
+			runId,
+			workspaceRoot: workspaceRoot()
+		}));
+	});
+	program.command("logs").description("Print whole-run or node-specific run-control artifacts").argument("<run-id>", "run id to inspect").argument("[node-id]", "node id whose artifacts should be printed").option("--follow", "continue printing appended artifact content while the run is active").action(async (runId, nodeId, flags) => {
+		await Effect.runPromise(printLogsEffect({
+			flags,
+			nodeId,
+			runId,
+			workspaceRoot: workspaceRoot()
+		}));
+	});
+	program.command("stop").description("Mark a Moka run or node as aborted").argument("<run-id>", "run id to stop").argument("[node-id]", "node id to stop without aborting sibling work").action(async (runId, nodeId) => {
+		await Effect.runPromise(stopRunOrNodeEffect({
+			nodeId,
+			runId,
+			workspaceRoot: workspaceRoot()
+		}).pipe(Effect.flatMap(logEffect)));
+	});
+	program.command("export").description("Print a sanitized portable run evidence bundle").argument("<run-id>", "run id to export").requiredOption("--sanitize", "omit prompt and session body text from exported artifacts").action(async (runId, flags) => {
+		if (!flags.sanitize) throw new Error("Run exports must be requested with --sanitize.");
+		await Effect.runPromise(exportSanitizedRunBundleEffect({
+			runId,
+			workspaceRoot: workspaceRoot()
+		}).pipe(Effect.map((bundle) => JSON.stringify(bundle)), Effect.flatMap(logEffect)));
+	});
+}
+function printRunsEffect(workspaceRoot) {
+	return listRunsNewestFirstEffect(workspaceRoot).pipe(Effect.map(formatRuns), Effect.flatMap(logEffect));
+}
+function printStatusEffect(input) {
+	return Effect.gen(function* () {
+		for (;;) {
+			const run = yield* resolveStatusRunEffect(input.workspaceRoot, input.runId);
+			yield* logEffect(input.flags.json ? JSON.stringify(runStatus(run)) : formatRunStatus(run));
+			if (!(input.flags.watch && isRunActive(run))) return;
+			yield* delayEffect(WATCH_INTERVAL_MS);
+		}
+	});
+}
+function printLogsEffect(input) {
+	return Effect.gen(function* () {
+		const run = yield* requireRunEffect(input.workspaceRoot, input.runId);
+		let artifacts = yield* readArtifactsEffect(input.workspaceRoot, run, input.nodeId);
+		yield* logEffect(formatArtifacts(artifacts));
+		if (!(input.flags.follow && isRunActive(run))) return;
+		const printedLengths = new Map(artifacts.map((artifact) => [artifactKey(artifact), artifact.content.length]));
+		for (;;) {
+			yield* delayEffect(WATCH_INTERVAL_MS);
+			const latestRun = yield* requireRunEffect(input.workspaceRoot, input.runId);
+			artifacts = yield* readArtifactsEffect(input.workspaceRoot, latestRun, input.nodeId);
+			const deltas = artifacts.map((artifact) => artifactDelta(artifact, printedLengths)).filter((artifact) => artifact !== void 0);
+			if (deltas.length > 0) yield* logEffect(formatArtifacts(deltas));
+			if (!isRunActive(latestRun)) return;
+		}
+	});
+}
+function stopRunOrNodeEffect(input) {
+	return Effect.gen(function* () {
+		const run = yield* requireRunEffect(input.workspaceRoot, input.runId);
+		const at = (/* @__PURE__ */ new Date()).toISOString();
+		if (input.nodeId) {
+			const nodeId = yield* requireKnownNodeEffect(run, input.nodeId);
+			yield* updateNodeStatusEffect({
+				at,
+				nodeId,
+				runId: run.runId,
+				status: "aborted",
+				workspaceRoot: input.workspaceRoot
+			});
+			return `Run ${run.runId} node ${nodeId} aborted.`;
+		}
+		yield* stopControllerProcessEffect(run);
+		yield* updateRunStatusEffect({
+			at,
+			runId: run.runId,
+			status: "aborted",
+			workspaceRoot: input.workspaceRoot
+		});
+		for (const [nodeId, status] of Object.entries(run.nodes)) {
+			if (!ACTIVE_NODE_STATUSES.has(status)) continue;
+			yield* updateNodeStatusEffect({
+				at,
+				nodeId,
+				runId: run.runId,
+				status: "aborted",
+				workspaceRoot: input.workspaceRoot
+			});
+		}
+		return `Run ${run.runId} aborted.`;
+	});
+}
+function exportSanitizedRunBundleEffect(input) {
+	return Effect.gen(function* () {
+		const run = yield* requireRunEffect(input.workspaceRoot, input.runId);
+		return {
+			artifacts: (yield* readArtifactsEffect(input.workspaceRoot, run)).filter((artifact) => !isSensitiveArtifactName(artifact.name)).map((artifact) => ({
+				content: artifact.content,
+				name: artifact.name,
+				nodeId: artifact.nodeId,
+				path: artifact.path
+			})),
+			run,
+			version: 1
+		};
+	});
+}
+function listRunsNewestFirstEffect(workspaceRoot) {
+	return Effect.gen(function* () {
+		const runs = yield* listRunsEffect({ workspaceRoot });
+		return (yield* Effect.forEach(runs, (run) => runSortTimeEffect(workspaceRoot, run.runId).pipe(Effect.map((sortTime) => ({
+			run,
+			sortTime
+		}))))).sort(compareRunsNewestFirst).map((record) => record.run);
+	});
+}
+function compareRunsNewestFirst(left, right) {
+	const timeOrder = right.sortTime - left.sortTime;
+	if (timeOrder !== 0) return timeOrder;
+	return right.run.runId.localeCompare(left.run.runId);
+}
+function runSortTimeEffect(workspaceRoot, runId) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => stat(join(workspaceRoot, RUNS_DIRECTORY, logicalSegment("runId", runId), MANIFEST_FILE))
+	}).pipe(Effect.map((manifest) => manifest.mtimeMs), Effect.catchAll((error) => isNotFound(error) ? Effect.succeed(0) : Effect.fail(error)));
+}
+function resolveStatusRunEffect(workspaceRoot, runId) {
+	return Effect.gen(function* () {
+		if (runId) return yield* requireRunEffect(workspaceRoot, runId);
+		const runs = yield* listRunsNewestFirstEffect(workspaceRoot);
+		const activeRuns = runs.filter(isRunActive);
+		if (activeRuns.length === 1) return activeRuns[0];
+		if (activeRuns.length > 1) return yield* Effect.fail(new Error(formatMultipleActiveRuns(activeRuns)));
+		if (runs.length === 0) return yield* Effect.fail(/* @__PURE__ */ new Error("No Moka runs found."));
+		return yield* Effect.fail(/* @__PURE__ */ new Error(`No active Moka runs found. Latest run is ${runs[0].runId} (${runs[0].status}); pass a run id explicitly.`));
+	});
+}
+function requireRunEffect(workspaceRoot, runId) {
+	return Effect.gen(function* () {
+		const run = yield* readRunEffect({
+			runId,
+			workspaceRoot
+		});
+		if (!run) return yield* Effect.fail(/* @__PURE__ */ new Error(`Run ${runId} does not exist.`));
+		return run;
+	});
+}
+function formatRuns(runs) {
+	if (runs.length === 0) return "No Moka runs found.";
+	return ["RUN ID	STATUS	TARGET	EFFORT	MODE	NODES"].concat(runs.map((run) => [
+		run.runId,
+		run.status,
+		run.target,
+		run.effort,
+		run.mode,
+		formatNodeSummary(run.nodes)
+	].join("	"))).join("\n");
+}
+function formatRunStatus(run) {
+	return [
+		`Run: ${run.runId}`,
+		`Status: ${run.status}`,
+		`Active: ${isRunActive(run) ? "yes" : "no"}`,
+		`Target: ${run.target}`,
+		`Effort: ${run.effort}`,
+		`Mode: ${run.mode}`,
+		"Nodes:",
+		...Object.entries(run.nodes).sort(([left], [right]) => left.localeCompare(right)).map(([nodeId, status]) => `- ${nodeId}: ${status}`),
+		`Events: ${run.events.length}`
+	].join("\n");
+}
+function runStatus(run) {
+	return {
+		active: isRunActive(run),
+		effort: run.effort,
+		events: run.events,
+		mode: run.mode,
+		nodes: run.nodes,
+		runId: run.runId,
+		status: run.status,
+		target: run.target
+	};
+}
+function formatArtifacts(artifacts) {
+	if (artifacts.length === 0) return "No artifacts found.";
+	return artifacts.map((artifact) => {
+		const content = artifact.content.endsWith("\n") ? artifact.content : `${artifact.content}\n`;
+		return `== ${artifact.nodeId}/${artifact.name} ==\n${content}`;
+	}).join("\n");
+}
+function formatMultipleActiveRuns(activeRuns) {
+	return ["Multiple active runs found; pass a run id explicitly:", ...activeRuns.map((run) => `- ${run.runId} (${run.status})`)].join("\n");
+}
+function readArtifactsEffect(workspaceRoot, run, nodeId) {
+	return Effect.gen(function* () {
+		const nodeIds = nodeId ? [yield* requireKnownNodeEffect(run, nodeId)] : Object.keys(run.nodes).sort((left, right) => left.localeCompare(right));
+		return (yield* Effect.forEach(nodeIds, (id) => readNodeArtifactsEffect(workspaceRoot, run.runId, id))).flat().sort((left, right) => `${left.nodeId}/${left.name}`.localeCompare(`${right.nodeId}/${right.name}`));
+	});
+}
+function readNodeArtifactsEffect(workspaceRoot, runId, nodeId) {
+	const nodeRoot = join(workspaceRoot, RUNS_DIRECTORY, logicalSegment("runId", runId), NODES_DIRECTORY, logicalSegment("nodeId", nodeId));
+	return Effect.gen(function* () {
+		const artifactPaths = yield* readArtifactPathsEffect(nodeRoot);
+		return yield* Effect.forEach(artifactPaths, (path) => readFileUtf8Effect(path).pipe(Effect.map((content) => ({
+			content,
+			name: normalizeRelative(nodeRoot, path),
+			nodeId,
+			path: normalizeRelative(workspaceRoot, path)
+		}))));
+	});
+}
+function readArtifactPathsEffect(current) {
+	return Effect.gen(function* () {
+		const entries = yield* readDirectoryEntriesEffect(current);
+		return (yield* Effect.forEach(entries.sort((left, right) => left.name.localeCompare(right.name)), (entry) => {
+			const path = join(current, entry.name);
+			if (entry.isDirectory()) return readArtifactPathsEffect(path);
+			if (!entry.isFile()) return Effect.succeed([]);
+			return Effect.succeed([path]);
+		})).flat();
+	});
+}
+function artifactDelta(artifact, printedLengths) {
+	const key = artifactKey(artifact);
+	const previousLength = printedLengths.get(key) ?? 0;
+	printedLengths.set(key, artifact.content.length);
+	if (artifact.content.length <= previousLength) return;
+	return {
+		...artifact,
+		content: artifact.content.slice(previousLength)
+	};
+}
+function artifactKey(artifact) {
+	return `${artifact.nodeId}/${artifact.name}`;
+}
+function formatNodeSummary(nodes) {
+	const entries = Object.entries(nodes).sort(([left], [right]) => left.localeCompare(right));
+	return entries.length === 0 ? "none" : entries.map(([nodeId, status]) => `${nodeId}=${status}`).join(",");
+}
+function isRunActive(run) {
+	return ACTIVE_RUN_STATUSES.has(run.status);
+}
+function requireKnownNode(run, nodeId) {
+	const logicalNodeId = logicalSegment("nodeId", nodeId);
+	if (!Object.hasOwn(run.nodes, logicalNodeId)) throw new Error(`Run ${run.runId} does not have node ${logicalNodeId}.`);
+	return logicalNodeId;
+}
+function requireKnownNodeEffect(run, nodeId) {
+	return Effect.try({
+		catch: (error) => error,
+		try: () => requireKnownNode(run, nodeId)
+	});
+}
+function stopControllerProcessEffect(run) {
+	return Effect.sync(() => {
+		const pid = run.controller?.pid;
+		if (!pid) return;
+		try {
+			process.kill(-pid, "SIGTERM");
+		} catch (error) {
+			if (isNoSuchProcess(error)) return;
+			process.kill(pid, "SIGTERM");
+		}
+	});
+}
+function readDirectoryEntriesEffect(current) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => readdir(current, { withFileTypes: true })
+	}).pipe(Effect.catchAll((error) => isNotFound(error) ? Effect.succeed([]) : Effect.fail(error)));
+}
+function readFileUtf8Effect(path) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => readFile(path, "utf8")
+	});
+}
+function delayEffect(milliseconds) {
+	return Effect.tryPromise({
+		catch: (error) => error,
+		try: () => setTimeout(milliseconds)
+	});
+}
+function logEffect(message) {
+	return Effect.sync(() => console.log(message));
+}
+function isSensitiveArtifactName(name) {
+	const normalized = name.toLowerCase();
+	const basename = normalized.split(PATH_SEPARATOR_RE).pop() ?? normalized;
+	return basename.includes("prompt") || basename.includes("session") || basename === "body" || basename.startsWith("body.") || normalized.includes("session-body") || normalized.includes("session_body");
+}
+function workspaceRoot() {
+	return process.env.PIPELINE_TARGET_PATH ?? process.cwd();
+}
+function logicalSegment(label, value) {
+	if (value.length === 0 || value.includes("/") || value.includes("\\") || value === "." || value === "..") throw new Error(`${label} must be a non-empty logical identifier.`);
+	return value;
+}
+function normalizeRelative(from, path) {
+	return relative(from, path).split(sep).join("/");
+}
+function isNotFound(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function isNoSuchProcess(error) {
+	return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+}
+//#endregion
+export { registerRunControlCommands };

package/dist/run-control/contracts.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+
+//#region src/run-control/contracts.d.ts
+declare const runTargetSchema: z.ZodEnum<{
+  local: "local";
+  remote: "remote";
+}>;
+declare const runEffortSchema: z.ZodEnum<{
+  quick: "quick";
+  normal: "normal";
+  thorough: "thorough";
+}>;
+declare const runModeSchema: z.ZodEnum<{
+  "read-only": "read-only";
+  write: "write";
+}>;
+type RunTarget = z.infer<typeof runTargetSchema>;
+type RunEffort = z.infer<typeof runEffortSchema>;
+type RunMode = z.infer<typeof runModeSchema>;
+//#endregion
+export { RunEffort, RunMode, RunTarget };

package/dist/run-control/contracts.js

@@ -0,0 +1,129 @@
+import { z } from "zod";
+//#region src/run-control/contracts.ts
+const RUN_TARGETS = ["local", "remote"];
+const RUN_EFFORTS = [
+	"quick",
+	"normal",
+	"thorough"
+];
+const RUN_MODES = ["read-only", "write"];
+/** Default fixed cadence for run-control heartbeat events. */
+const DEFAULT_RUN_CONTROL_HEARTBEAT_INTERVAL_MS = 3e4;
+/**
+* Default silence threshold before an active run-control node is marked
+* stalled. This only changes observability state; it does not kill work.
+*/
+const DEFAULT_RUN_CONTROL_NODE_STALE_AFTER_MS = 12e4;
+const DEFAULT_RUN_CONTROL_STALE_DETECTION = {
+	heartbeatIntervalMs: DEFAULT_RUN_CONTROL_HEARTBEAT_INTERVAL_MS,
+	nodeStaleAfterMs: DEFAULT_RUN_CONTROL_NODE_STALE_AFTER_MS
+};
+const MOKA_RUN_STATUSES = [
+	"queued",
+	"starting",
+	"running",
+	"stalled",
+	"passed",
+	"failed",
+	"timed_out",
+	"aborted",
+	"blocked"
+];
+const MOKA_NODE_STATUSES = [
+	"queued",
+	"starting",
+	"running",
+	"stalled",
+	"passed",
+	"failed",
+	"timed_out",
+	"aborted",
+	"blocked"
+];
+const runTargetSchema = z.enum(RUN_TARGETS);
+const runEffortSchema = z.enum(RUN_EFFORTS);
+const runModeSchema = z.enum(RUN_MODES);
+const mokaRunStatusSchema = z.enum(MOKA_RUN_STATUSES);
+const mokaNodeStatusSchema = z.enum(MOKA_NODE_STATUSES);
+const nonEmptyStringSchema = z.string().min(1);
+const eventTimestampSchema = z.string().datetime();
+const positiveMillisecondsSchema = z.number().int().positive();
+const runControlStaleDetectionSchema = z.object({
+	heartbeatIntervalMs: positiveMillisecondsSchema,
+	nodeStaleAfterMs: positiveMillisecondsSchema
+}).strict();
+const mokaRunControllerSchema = z.object({
+	argv: z.array(nonEmptyStringSchema),
+	cwd: nonEmptyStringSchema,
+	paths: z.object({
+		events: nonEmptyStringSchema,
+		manifest: nonEmptyStringSchema,
+		status: nonEmptyStringSchema
+	}).strict(),
+	pid: z.number().int().positive(),
+	startedAt: eventTimestampSchema
+}).strict();
+const mokaRunStatusEventSchema = z.object({
+	at: eventTimestampSchema,
+	status: mokaRunStatusSchema,
+	type: z.literal("run.status")
+}).strict();
+const mokaNodeStatusEventSchema = z.object({
+	at: eventTimestampSchema,
+	nodeId: nonEmptyStringSchema,
+	status: mokaNodeStatusSchema,
+	type: z.literal("node.status")
+}).strict();
+const mokaRunHeartbeatEventSchema = z.object({
+	at: eventTimestampSchema,
+	heartbeatIntervalMs: positiveMillisecondsSchema,
+	nodeId: z.never().optional(),
+	status: z.never().optional(),
+	type: z.literal("run.heartbeat")
+}).strict();
+const mokaRunEventSchema = z.discriminatedUnion("type", [mokaRunStatusEventSchema, mokaNodeStatusEventSchema]);
+const mokaRunControlEventSchema = z.discriminatedUnion("type", [
+	mokaRunHeartbeatEventSchema,
+	mokaRunStatusEventSchema,
+	mokaNodeStatusEventSchema
+]);
+const mokaRunManifestSchema = z.object({
+	controller: mokaRunControllerSchema.optional(),
+	effort: runEffortSchema,
+	events: z.array(mokaRunEventSchema),
+	mode: runModeSchema,
+	nodes: z.record(nonEmptyStringSchema, mokaNodeStatusSchema),
+	runId: nonEmptyStringSchema,
+	staleDetection: runControlStaleDetectionSchema.optional(),
+	status: mokaRunStatusSchema,
+	target: runTargetSchema
+}).strict();
+function parseRunTarget(input) {
+	return runTargetSchema.parse(input);
+}
+function parseRunEffort(input) {
+	return runEffortSchema.parse(input);
+}
+function parseRunMode(input) {
+	return runModeSchema.parse(input);
+}
+function parseMokaRunStatus(input) {
+	return mokaRunStatusSchema.parse(input);
+}
+function parseMokaNodeStatus(input) {
+	return mokaNodeStatusSchema.parse(input);
+}
+function parseRunControlStaleDetection(input) {
+	return runControlStaleDetectionSchema.parse(input);
+}
+function parseMokaRunController(input) {
+	return mokaRunControllerSchema.parse(input);
+}
+function parseMokaRunEvent(input) {
+	return mokaRunControlEventSchema.parse(input);
+}
+function parseMokaRunManifest(input) {
+	return mokaRunManifestSchema.parse(input);
+}
+//#endregion
+export { DEFAULT_RUN_CONTROL_HEARTBEAT_INTERVAL_MS, DEFAULT_RUN_CONTROL_NODE_STALE_AFTER_MS, DEFAULT_RUN_CONTROL_STALE_DETECTION, parseMokaNodeStatus, parseMokaRunController, parseMokaRunEvent, parseMokaRunManifest, parseMokaRunStatus, parseRunControlStaleDetection, parseRunEffort, parseRunMode, parseRunTarget };

package/dist/run-control/detach.js

@@ -0,0 +1,79 @@
+import { Effect } from "effect";
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+//#region src/run-control/detach.ts
+function startDetachedRunController(input) {
+	return Effect.runPromise(startDetachedRunControllerEffect(input));
+}
+function startDetachedRunControllerEffect(input) {
+	return Effect.gen(function* () {
+		const command = process.execPath;
+		const args = yield* controllerArgsEffect(input);
+		const child = yield* Effect.sync(() => spawn(command, args, {
+			cwd: input.workspaceRoot,
+			detached: true,
+			env: {
+				...process.env,
+				PIPELINE_TARGET_PATH: input.workspaceRoot
+			},
+			stdio: "ignore"
+		}));
+		if (!child.pid) return yield* Effect.fail(/* @__PURE__ */ new Error("Detached run controller did not expose a process id."));
+		yield* waitForControllerSpawnEffect(child);
+		yield* Effect.sync(() => child.unref());
+		return {
+			argv: [command, ...args],
+			pid: child.pid,
+			startedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	});
+}
+function controllerArgsEffect(input) {
+	return Effect.gen(function* () {
+		return [
+			yield* cliEntrypointPathEffect(),
+			"run-controller",
+			"--run-id",
+			input.runId,
+			...optionalOption("--schedule", input.schedule),
+			...optionalOption("--entrypoint", input.entrypoint),
+			...optionalOption("--workflow", input.workflow),
+			"--",
+			input.task
+		];
+	});
+}
+function optionalOption(name, value) {
+	return value ? [name, value] : [];
+}
+function cliEntrypointPathEffect() {
+	return Effect.gen(function* () {
+		const envEntrypoint = process.env.MOKA_CLI_ENTRYPOINT;
+		if (envEntrypoint) return envEntrypoint;
+		const moduleDir = dirname(fileURLToPath(import.meta.url));
+		const compiledEntrypoint = join(moduleDir, "..", "index.js");
+		if (yield* pathExistsEffect(compiledEntrypoint)) return compiledEntrypoint;
+		const sourceEntrypoint = join(moduleDir, "..", "index.ts");
+		if (yield* pathExistsEffect(sourceEntrypoint)) return sourceEntrypoint;
+		return process.argv[1] ?? compiledEntrypoint;
+	});
+}
+function pathExistsEffect(path) {
+	return Effect.sync(() => existsSync(path));
+}
+function waitForControllerSpawnEffect(child) {
+	return Effect.async((resume) => {
+		const onSpawn = () => resume(Effect.void);
+		const onError = (error) => resume(Effect.fail(error));
+		child.once("spawn", onSpawn);
+		child.once("error", onError);
+		return Effect.sync(() => {
+			child.off("spawn", onSpawn);
+			child.off("error", onError);
+		});
+	});
+}
+//#endregion
+export { startDetachedRunController };