@oisincoveney/pipeline 3.24.2 → 3.24.3

package/dist/run-control/runtime-reporter.js

@@ -1,56 +1,53 @@
 import { createSerializedWriteQueue } from "../serialized-write-queue.js";
 import { withRunStateLock } from "./run-state-lock.js";
 import { createRuntimeEventProjectionState, projectRuntimeEvent } from "./runtime-event-projection.js";
-import { Effect } from "effect";
 import { isAbsolute, join } from "node:path";
+import { Effect } from "effect";
 import { appendFile, mkdir } from "node:fs/promises";
 //#region src/run-control/runtime-reporter.ts
 const RUNS_DIRECTORY = ".pipeline/runs";
 const RUNTIME_EVENTS_FILE = "runtime-events.jsonl";
 const NODES_DIRECTORY = "nodes";
 const STDOUT_ARTIFACT = "stdout.jsonl";
-function createRunStoreRuntimeReporter(input) {
-	return Effect.runSync(createRunStoreRuntimeReporterEffect(input));
-}
-function createRunStoreRuntimeReporterEffect(input) {
-	return Effect.sync(() => createRunStoreRuntimeReporterRuntime(input));
-}
-function createRunStoreRuntimeReporterRuntime(input) {
-	const now = input.now ?? (() => /* @__PURE__ */ new Date());
-	const store = input.store;
-	let projectionState = createRuntimeEventProjectionState();
-	const writes = createSerializedWriteQueue();
-	const enqueue = (event) => {
-		const projection = projectRuntimeEvent(event, projectionState);
-		projectionState = projection.state;
-		const persisted = persistRuntimeEventEffect(input, store, event, projection.writes, now).pipe(Effect.catch((error) => warnPersistSkipped(input, event, error)));
-		writes.enqueue(() => withRunStateLock(() => Effect.runPromise(persisted)));
-	};
-	const flushEffect = () => Effect.tryPromise({
-		catch: (error) => error,
-		try: () => writes.flush()
-	});
-	return {
-		flush: () => Effect.runPromise(flushEffect()),
-		flushEffect,
-		reporter(event) {
-			enqueue(event);
-			input.reporter?.(event);
-		}
-	};
-}
-function persistRuntimeEventEffect(input, store, event, writeIntents, now) {
-	return Effect.gen(function* () {
-		const writesFilesystemObservability = writesFilesystemRunState(store, input.runId);
-		if (writesFilesystemObservability) yield* appendRuntimeEventEffect(input, event);
-		for (const writeIntent of writeIntents) yield* persistStoreWriteIntentEffect(input, store, writeIntent, now);
-		if (writesFilesystemObservability && event.type === "node.output.recorded") yield* appendNodeStdoutEffect(input, event.nodeId, event);
-	});
-}
-function writesFilesystemRunState(store, runId) {
-	return store.statusPaths({ runId }).manifest.startsWith(`${RUNS_DIRECTORY}/`);
-}
-function persistStoreWriteIntentEffect(input, store, writeIntent, now) {
+const writesFilesystemRunState = (store, runId) => store.statusPaths({ runId }).manifest.startsWith(`${RUNS_DIRECTORY}/`);
+const appendJsonlEffect = (path, value) => Effect.tryPromise({
+	catch: (error) => error,
+	try: async () => {
+		await appendFile(path, `${JSON.stringify(value)}\n`, "utf-8");
+	}
+});
+const mkdirEffect = (path, options) => Effect.tryPromise({
+	catch: (error) => error,
+	try: async () => await mkdir(path, options)
+}).pipe(Effect.asVoid);
+const logicalSegment = (label, value) => {
+	if (value.length === 0 || isAbsolute(value) || value.includes("/") || value.includes("\\") || value === "." || value === "..") throw new Error(`${label} must be a non-empty logical identifier.`);
+	return value;
+};
+const runDirectory = (workspaceRoot, runId) => join(workspaceRoot, RUNS_DIRECTORY, logicalSegment("runId", runId));
+const runDirectoryEffect = (workspaceRoot, runId) => Effect.try({
+	catch: (error) => error,
+	try: () => runDirectory(workspaceRoot, runId)
+});
+const appendRuntimeEventEffect = (input, event) => Effect.gen(function* effectBody() {
+	const runRoot = yield* runDirectoryEffect(input.workspaceRoot, input.runId);
+	yield* mkdirEffect(runRoot, { recursive: true });
+	yield* appendJsonlEffect(join(runRoot, RUNTIME_EVENTS_FILE), event);
+});
+const logicalSegmentEffect = (label, value) => Effect.try({
+	catch: (error) => error,
+	try: () => logicalSegment(label, value)
+});
+const appendNodeStdoutEffect = (input, nodeId, event) => Effect.gen(function* effectBody() {
+	const nodeRoot = join(yield* runDirectoryEffect(input.workspaceRoot, input.runId), NODES_DIRECTORY, yield* logicalSegmentEffect("nodeId", nodeId));
+	yield* mkdirEffect(nodeRoot, { recursive: true });
+	yield* appendJsonlEffect(join(nodeRoot, STDOUT_ARTIFACT), event);
+});
+const timestamp = (now) => now().toISOString();
+const assertNever = (value) => {
+	throw new Error(`Unhandled runtime reporter value: ${String(value)}`);
+};
+const persistStoreWriteIntentEffect = (input, store, writeIntent, now) => {
 	switch (writeIntent.type) {
 		case "node.session": return store.updateNodeSession({
 			nodeId: writeIntent.nodeId,
@@ -70,66 +67,51 @@ function persistStoreWriteIntentEffect(input, store, writeIntent, now) {
 		});
 		default: return assertNever(writeIntent);
 	}
-}
-function appendRuntimeEventEffect(input, event) {
-	return Effect.gen(function* () {
-		const runRoot = yield* runDirectoryEffect(input.workspaceRoot, input.runId);
-		yield* mkdirEffect(runRoot, { recursive: true });
-		yield* appendJsonlEffect(join(runRoot, RUNTIME_EVENTS_FILE), event);
-	});
-}
-function appendNodeStdoutEffect(input, nodeId, event) {
-	return Effect.gen(function* () {
-		const nodeRoot = join(yield* runDirectoryEffect(input.workspaceRoot, input.runId), NODES_DIRECTORY, yield* logicalSegmentEffect("nodeId", nodeId));
-		yield* mkdirEffect(nodeRoot, { recursive: true });
-		yield* appendJsonlEffect(join(nodeRoot, STDOUT_ARTIFACT), event);
-	});
-}
-function appendJsonlEffect(path, value) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: () => appendFile(path, `${JSON.stringify(value)}\n`, "utf8")
-	});
-}
-function mkdirEffect(path, options) {
-	return Effect.tryPromise({
-		catch: (error) => error,
-		try: () => mkdir(path, options)
-	}).pipe(Effect.asVoid);
-}
-function runDirectory(workspaceRoot, runId) {
-	return join(workspaceRoot, RUNS_DIRECTORY, logicalSegment("runId", runId));
-}
-function runDirectoryEffect(workspaceRoot, runId) {
-	return Effect.try({
-		catch: (error) => error,
-		try: () => runDirectory(workspaceRoot, runId)
-	});
-}
-function logicalSegment(label, value) {
-	if (value.length === 0 || isAbsolute(value) || value.includes("/") || value.includes("\\") || value === "." || value === "..") throw new Error(`${label} must be a non-empty logical identifier.`);
-	return value;
-}
-function logicalSegmentEffect(label, value) {
-	return Effect.try({
+};
+const persistRuntimeEventEffect = (input, store, event, writeIntents, now) => Effect.gen(function* effectBody() {
+	const writesFilesystemObservability = writesFilesystemRunState(store, input.runId);
+	if (writesFilesystemObservability) yield* appendRuntimeEventEffect(input, event);
+	for (const writeIntent of writeIntents) yield* persistStoreWriteIntentEffect(input, store, writeIntent, now);
+	if (writesFilesystemObservability && event.type === "node.output.recorded") yield* appendNodeStdoutEffect(input, event.nodeId, event);
+});
+const errorMessage = (error) => error instanceof Error ? error.message : String(error);
+const warnPersistSkipped = (input, event, error) => Effect.sync(() => {
+	const nodeId = "nodeId" in event && typeof event.nodeId === "string" ? ` node=${event.nodeId}` : "";
+	process.stderr.write(`run-control: skipped persisting ${event.type}${nodeId} for run ${input.runId}: ${errorMessage(error)}\n`);
+});
+const createRunStoreRuntimeReporterRuntime = (input) => {
+	const now = input.now ?? (() => /* @__PURE__ */ new Date());
+	const { store } = input;
+	let projectionState = createRuntimeEventProjectionState();
+	const writes = createSerializedWriteQueue();
+	const enqueue = (event) => {
+		const projection = projectRuntimeEvent(event, projectionState);
+		projectionState = projection.state;
+		const persisted = persistRuntimeEventEffect(input, store, event, projection.writes, now).pipe(Effect.catch((error) => warnPersistSkipped(input, event, error)));
+		writes.enqueue(async () => {
+			await withRunStateLock(async () => {
+				await Effect.runPromise(persisted);
+			});
+		});
+	};
+	const flushEffect = () => Effect.tryPromise({
 		catch: (error) => error,
-		try: () => logicalSegment(label, value)
-	});
-}
-function timestamp(now) {
-	return now().toISOString();
-}
-function assertNever(value) {
-	throw new Error(`Unhandled runtime reporter value: ${String(value)}`);
-}
-function warnPersistSkipped(input, event, error) {
-	return Effect.sync(() => {
-		const nodeId = "nodeId" in event && typeof event.nodeId === "string" ? ` node=${event.nodeId}` : "";
-		process.stderr.write(`run-control: skipped persisting ${event.type}${nodeId} for run ${input.runId}: ${errorMessage(error)}\n`);
+		try: async () => {
+			await writes.flush();
+		}
 	});
-}
-function errorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
-}
+	return {
+		flush: async () => {
+			await Effect.runPromise(flushEffect());
+		},
+		flushEffect,
+		reporter(event) {
+			enqueue(event);
+			input.reporter?.(event);
+		}
+	};
+};
+const createRunStoreRuntimeReporterEffect = (input) => Effect.sync(() => createRunStoreRuntimeReporterRuntime(input));
+const createRunStoreRuntimeReporter = (input) => Effect.runSync(createRunStoreRuntimeReporterEffect(input));
 //#endregion
 export { createRunStoreRuntimeReporter, createRunStoreRuntimeReporterEffect };

package/dist/run-control/stop-command.js

@@ -1,60 +1,49 @@
 import { ACTIVE_NODE_STATUSES, requireKnownNodeEffect } from "./run-command-domain.js";
 import { requireRunEffect } from "./run-query-command.js";
-import { Effect } from "effect";
+import { Effect, Option } from "effect";
 //#region src/run-control/stop-command.ts
-function stopRunOrNodeEffect(input) {
-	return Effect.gen(function* () {
-		const run = yield* requireRunEffect(input.store, input.runId);
-		const at = (/* @__PURE__ */ new Date()).toISOString();
-		if (input.nodeId) return yield* stopNodeEffect(input.store, run, input.nodeId, at);
-		return yield* stopRunEffect(input.store, run, at);
+const stopNodeEffect = (store, run, requestedNodeId, at) => Effect.gen(function* effectBody() {
+	const nodeId = yield* requireKnownNodeEffect(run, requestedNodeId);
+	yield* store.updateNodeStatus({
+		at,
+		nodeId,
+		runId: run.runId,
+		status: "aborted"
 	});
-}
-function stopNodeEffect(store, run, requestedNodeId, at) {
-	return Effect.gen(function* () {
-		const nodeId = yield* requireKnownNodeEffect(run, requestedNodeId);
-		yield* store.updateNodeStatus({
-			at,
-			nodeId,
-			runId: run.runId,
-			status: "aborted"
-		});
-		return `Run ${run.runId} node ${nodeId} aborted.`;
+	return `Run ${run.runId} node ${nodeId} aborted.`;
+});
+const activeNodeIds = (run) => Object.entries(run.nodes).filter(([, status]) => ACTIVE_NODE_STATUSES.has(status)).map(([nodeId]) => nodeId);
+const isNoSuchProcess = (error) => typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
+const stopControllerProcessEffect = (pid) => Effect.sync(() => {
+	if (Option.isNone(pid) || pid.value === 0) return;
+	try {
+		process.kill(-pid.value, "SIGTERM");
+	} catch (error) {
+		if (isNoSuchProcess(error)) return;
+		process.kill(pid.value, "SIGTERM");
+	}
+});
+const stopRunEffect = (store, run, at) => Effect.gen(function* effectBody() {
+	yield* stopControllerProcessEffect(Option.fromNullishOr(run.controller?.pid));
+	yield* store.updateRunStatus({
+		at,
+		runId: run.runId,
+		status: "aborted"
 	});
-}
-function stopRunEffect(store, run, at) {
-	return Effect.gen(function* () {
-		yield* stopControllerProcessEffect(run.controller?.pid);
-		yield* store.updateRunStatus({
-			at,
-			runId: run.runId,
-			status: "aborted"
-		});
-		yield* Effect.forEach(activeNodeIds(run), (nodeId) => store.updateNodeStatus({
-			at,
-			nodeId,
-			runId: run.runId,
-			status: "aborted"
-		}));
-		return `Run ${run.runId} aborted.`;
-	});
-}
-function activeNodeIds(run) {
-	return Object.entries(run.nodes).filter(([, status]) => ACTIVE_NODE_STATUSES.has(status)).map(([nodeId]) => nodeId);
-}
-function stopControllerProcessEffect(pid) {
-	return Effect.sync(() => {
-		if (!pid) return;
-		try {
-			process.kill(-pid, "SIGTERM");
-		} catch (error) {
-			if (isNoSuchProcess(error)) return;
-			process.kill(pid, "SIGTERM");
-		}
-	});
-}
-function isNoSuchProcess(error) {
-	return typeof error === "object" && error !== null && "code" in error && error.code === "ESRCH";
-}
+	yield* Effect.forEach(activeNodeIds(run), (nodeId) => store.updateNodeStatus({
+		at,
+		nodeId,
+		runId: run.runId,
+		status: "aborted"
+	}));
+	return `Run ${run.runId} aborted.`;
+});
+const stopRunOrNodeEffect = (input) => Effect.gen(function* effectBody() {
+	const run = yield* requireRunEffect(input.store, input.runId);
+	const at = (/* @__PURE__ */ new Date()).toISOString();
+	const nodeId = Option.fromNullishOr(input.nodeId).pipe(Option.filter((value) => value.length > 0));
+	if (Option.isSome(nodeId)) return yield* stopNodeEffect(input.store, run, nodeId.value, at);
+	return yield* stopRunEffect(input.store, run, at);
+});
 //#endregion
 export { stopRunOrNodeEffect };

package/dist/run-control/store-fs-effects.js

@@ -1,3 +1,5 @@
-import "effect";
+import { Option } from "effect";
 import "node:fs/promises";
+Option.none();
+//#endregion
 export {};

package/dist/run-control/store-manifest.js

@@ -1,28 +1,53 @@
+import { requiredString, struct } from "../schema-boundary.js";
 import { mokaNodeStatusSchema, mokaRunStatusSchema, parseMokaRunManifest } from "./contracts.js";
 import { parseLogicalSegment } from "./logical-segment.js";
-import { z } from "zod";
+import "effect/Option";
+import * as R from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as Arr from "effect/Array";
+import "effect/Match";
+import * as Str from "effect/String";
 //#region src/run-control/store-manifest.ts
-const runStatusNodeSchema = z.union([mokaNodeStatusSchema, z.object({
-	sessionId: z.string().min(1).optional(),
+const runStatusNode = Schema.Union([mokaNodeStatusSchema, struct({
+	sessionId: Schema.optional(requiredString),
 	status: mokaNodeStatusSchema
-}).strict()]);
-z.object({
-	nodes: z.record(z.string().min(1), runStatusNodeSchema),
+})]);
+struct({
+	nodes: Schema.Record(requiredString, runStatusNode),
 	status: mokaRunStatusSchema
-}).strict();
-z.object({ sessionId: z.string().min(1) }).passthrough();
-function publishScheduleManifest(input) {
-	if (input.schedule.length === 0) throw new Error("schedule must be a non-empty string.");
-	if (input.manifest.schedule !== void 0 && input.manifest.schedule !== input.schedule) throw new Error(`Run ${input.manifest.runId} already has a different published schedule.`);
+});
+struct({ sessionId: requiredString });
+var EmptyPublishedScheduleError = class extends Schema.TaggedErrorClass()("EmptyPublishedScheduleError", { message: Schema.String }) {
+	constructor() {
+		super({ message: "schedule must be a non-empty string." });
+	}
+};
+var PublishedScheduleConflictError = class extends Schema.TaggedErrorClass()("PublishedScheduleConflictError", {
+	message: Schema.String,
+	runId: requiredString
+}) {
+	constructor(runId) {
+		super({
+			message: `Run ${runId} already has a different published schedule.`,
+			runId
+		});
+	}
+};
+const queuedNodeEntry = (nodeId) => [nodeId, "queued"];
+const queuedNodeRecord = (nodeIds) => R.fromEntries(Arr.map(nodeIds, queuedNodeEntry));
+const publishScheduleManifest = (input) => {
+	if (Str.isEmpty(input.schedule)) throw new EmptyPublishedScheduleError();
+	if (input.manifest.schedule !== void 0 && input.manifest.schedule !== input.schedule) throw new PublishedScheduleConflictError(input.manifest.runId);
 	const nodeIds = input.nodeIds.map((nodeId) => parseLogicalSegment("nodeId", nodeId));
+	const missingNodes = Arr.filter(nodeIds, (nodeId) => !R.has(input.manifest.nodes, nodeId));
 	return parseMokaRunManifest({
 		...input.manifest,
 		nodes: {
 			...input.manifest.nodes,
-			...Object.fromEntries(nodeIds.filter((nodeId) => !(nodeId in input.manifest.nodes)).map((nodeId) => [nodeId, "queued"]))
+			...queuedNodeRecord(missingNodes)
 		},
 		schedule: input.schedule
 	});
-}
+};
 //#endregion
 export { publishScheduleManifest };

package/dist/run-control/store-paths.js

@@ -1,13 +1,13 @@
 import "./logical-segment.js";
-import "effect";
 import { join } from "node:path";
+import "effect";
 //#region src/run-control/store-paths.ts
 const RUNS_DIRECTORY = ".pipeline/runs";
 const MANIFEST_FILE = "manifest.json";
 const STATUS_FILE = "status.json";
 const EVENTS_FILE = "events.jsonl";
 const NODES_DIRECTORY = "nodes";
-function runPaths(workspaceRoot, runId) {
+const runPaths = (workspaceRoot, runId) => {
 	const runsRoot = join(workspaceRoot, RUNS_DIRECTORY);
 	const runRoot = join(runsRoot, runId);
 	return {
@@ -18,6 +18,6 @@ function runPaths(workspaceRoot, runId) {
 		runsRoot,
 		status: join(runRoot, STATUS_FILE)
 	};
-}
+};
 //#endregion
 export { RUNS_DIRECTORY, runPaths };

package/dist/run-control/store.js

@@ -4,6 +4,6 @@ import "./store-manifest.js";
 import "./store-fs-effects.js";
 import "./store-paths.js";
 import "./workspace.js";
-import "effect";
 import "node:path";
+import "effect";
 export {};

package/dist/run-control/submit-result.js

@@ -2,11 +2,11 @@ import { loadMokaDbUrl } from "../moka-global-config.js";
 import { recordNodeResult } from "../runtime/step/step-node.js";
 import { resolveDurableStore } from "../runtime/durable-store/acquisition.js";
 import { parseSubmitResult } from "../runtime/node-protocol/node-protocol.js";
-import { Effect } from "effect";
+import * as Effect from "effect/Effect";
 //#region src/run-control/submit-result.ts
 /**
 * PIPE-91.7: validate and persist a node's terminal result into the durable
-* store. Throws a {@link z.ZodError} on malformed payload or a
+* store. Throws an Effect Schema validation error on malformed payload or a
 * `result.nodeId !== nodeId` mismatch; throws a {@link SyntaxError} on
 * invalid JSON.
 *
@@ -16,7 +16,7 @@ import { Effect } from "effect";
 * gate evaluation must look up the schedule artifact, not this store entry.
 * `inputs` are opaque and `undefined` until a future lane pins the schema.
 */
-function recordSubmitResult(input) {
+const recordSubmitResult = (input) => {
 	const raw = JSON.parse(input.resultJson);
 	const parsed = parseSubmitResult({
 		nodeId: input.nodeId,
@@ -28,7 +28,22 @@ function recordSubmitResult(input) {
 		runId: parsed.runId,
 		store: input.store
 	});
-}
+};
+const submitResultEffect = (runId, nodeId, resultJson) => Effect.scoped(Effect.gen(function* effectBody() {
+	const store = yield* resolveDurableStore(loadMokaDbUrl(), runId);
+	yield* Effect.try({
+		catch: (error) => error,
+		try: () => {
+			recordSubmitResult({
+				nodeId,
+				resultJson,
+				runId,
+				store
+			});
+		}
+	});
+	process.stdout.write(`Recorded result for run ${runId} node ${nodeId}.\n`);
+}));
 /**
 * PIPE-91.7: register `moka submit-result <run-id> <node-id> --json <payload>`.
 * A distinct top-level command (NOT a `submit` group — `moka submit` already
@@ -36,25 +51,10 @@ function recordSubmitResult(input) {
 * string; `(runId, nodeId)` are the positional routing keys — mirroring
 * `moka next node <run-id>` (PIPE-91.6).
 */
-function registerSubmitResultSubcommand(program) {
+const registerSubmitResultSubcommand = (program) => {
 	program.command("submit-result").description("Persist a node's terminal result into the durable run store").argument("<run-id>", "the run id to persist the result under").argument("<node-id>", "the node id whose result is being submitted").requiredOption("--json <payload>", "the RuntimeNodeResult as a JSON string").action(async (runId, nodeId, flags) => {
 		await Effect.runPromise(submitResultEffect(runId, nodeId, flags.json));
 	});
-}
-function submitResultEffect(runId, nodeId, resultJson) {
-	return Effect.scoped(Effect.gen(function* () {
-		const store = yield* resolveDurableStore(loadMokaDbUrl(), runId);
-		yield* Effect.try({
-			catch: (error) => error,
-			try: () => recordSubmitResult({
-				nodeId,
-				resultJson,
-				runId,
-				store
-			})
-		});
-		process.stdout.write(`Recorded result for run ${runId} node ${nodeId}.\n`);
-	}));
-}
+};
 //#endregion
 export { recordSubmitResult, registerSubmitResultSubcommand };