@smithers-orchestrator/engine 0.16.0

package/src/index.js

@@ -0,0 +1,41 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ChildWorkflowDefinition.ts").ChildWorkflowDefinition} ChildWorkflowDefinition */
+// @smithers-type-exports-end
+
+export { runWorkflow } from "./engine.js";
+export { renderFrame } from "./engine.js";
+export { resolveSchema } from "./engine.js";
+export { isRunHeartbeatFresh } from "./engine.js";
+
+// Top-level public modules
+export * from "./alert-runtime.js";
+export * from "./approvals.js";
+export * from "./child-workflow.js";
+export * from "./events.js";
+export * from "./getDefinedToolMetadata.js";
+export * from "./human-requests.js";
+export * from "./runtime-owner.js";
+export * from "./scheduler.js";
+export * from "./signals.js";
+
+// Hot reload public surface (aggregated in hot/index.js)
+export * from "./hot/index.js";
+
+// Effect bridge public surface.
+// workflow-bridge.js is the authoritative umbrella for: durable-deferred-bridge,
+// deferred-state-bridge, workflow-make-bridge, sql-message-storage, entity-worker,
+// single-runner, http-runner.
+export * from "./effect/workflow-bridge.js";
+export * from "./effect/activity-bridge.js";
+export * from "./effect/bridge-utils.js";
+export * from "./effect/builder.js";
+export * from "./effect/compute-task-bridge.js";
+// (bridgeApprovalResolve / bridgeTimerResolve namespace comes from workflow-bridge.js via durable-deferred-bridge.js)
+// deferred-bridge.js is intentionally not re-exported to avoid collisions with the durable variants.
+export * from "./effect/diff-bundle.js";
+export * from "./effect/rpc-schema.js";
+export * from "./effect/static-task-bridge.js";
+export * from "./effect/versioning.js";
+
+// External helpers
+export * from "./external/json-schema-to-zod.js";

package/src/runtime-owner.js

@@ -0,0 +1,36 @@
+/**
+ * @param {string | null | undefined} runtimeOwnerId
+ * @returns {number | null}
+ */
+export function parseRuntimeOwnerPid(runtimeOwnerId) {
+    if (!runtimeOwnerId)
+        return null;
+    const trimmed = runtimeOwnerId.trim();
+    if (trimmed.length === 0)
+        return null;
+    const exact = trimmed.match(/^pid:(\d+)(?::.*)?$/i);
+    if (exact) {
+        const pid = Number(exact[1]);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    if (/^\d+$/.test(trimmed)) {
+        const pid = Number(trimmed);
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    return null;
+}
+/**
+ * @param {number} pid
+ * @returns {boolean}
+ */
+export function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error?.code === "EPERM";
+    }
+}

package/src/scheduler.js

@@ -0,0 +1,31 @@
+// @smithers-type-exports-begin
+/** @typedef {import("./ContinuationRequest.ts").ContinuationRequest} ContinuationRequest */
+/** @typedef {import("./PlanNode.ts").PlanNode} PlanNode */
+/** @typedef {import("./RalphMeta.ts").RalphMeta} RalphMeta */
+/** @typedef {import("./RalphState.ts").RalphState} RalphState */
+/** @typedef {import("./RalphStateMap.ts").RalphStateMap} RalphStateMap */
+/** @typedef {import("@smithers-orchestrator/scheduler").ReadonlyTaskStateMap} ReadonlyTaskStateMap */
+/** @typedef {import("@smithers-orchestrator/scheduler").RetryWaitMap} RetryWaitMap */
+/** @typedef {import("./ScheduleResult.ts").ScheduleResult} ScheduleResult */
+/** @typedef {import("@smithers-orchestrator/scheduler").ScheduleSnapshot} ScheduleSnapshot */
+/** @typedef {import("@smithers-orchestrator/scheduler").TaskRecord} TaskRecord */
+/** @typedef {import("@smithers-orchestrator/scheduler").TaskState} TaskState */
+/** @typedef {import("@smithers-orchestrator/scheduler").TaskStateMap} TaskStateMap */
+/** @typedef {import("@smithers-orchestrator/graph/TaskDescriptor").TaskDescriptor} _TaskDescriptor */
+/** @typedef {import("@smithers-orchestrator/graph/XmlNode").XmlNode} XmlNode */
+// @smithers-type-exports-end
+
+import { buildPlanTree as coreBuildPlanTree, scheduleTasks as coreScheduleTasks, } from "@smithers-orchestrator/scheduler";
+export { buildStateKey } from "@smithers-orchestrator/scheduler";
+export { Scheduler, SchedulerLive } from "@smithers-orchestrator/scheduler";
+export { cloneTaskStateMap, isTerminalState, parseStateKey, } from "@smithers-orchestrator/scheduler";
+
+/**
+ * @type {(xml: XmlNode | null, ralphState?: RalphStateMap) => { plan: PlanNode | null; ralphs: RalphMeta[] }}
+ */
+export const buildPlanTree = coreBuildPlanTree;
+
+/**
+ * @type {(plan: PlanNode | null, states: TaskStateMap, descriptors: Map<string, _TaskDescriptor>, ralphState: RalphStateMap, retryWait: Map<string, number>, nowMs: number) => ScheduleResult}
+ */
+export const scheduleTasks = coreScheduleTasks;

package/src/signals.js

@@ -0,0 +1,82 @@
+import { Effect } from "effect";
+import { SmithersDb } from "@smithers-orchestrator/db/adapter";
+import { bridgeSignalResolve } from "./effect/durable-deferred-bridge.js";
+import { SmithersError } from "@smithers-orchestrator/errors/SmithersError";
+import { nowMs } from "@smithers-orchestrator/scheduler/nowMs";
+/** @typedef {import("./SignalRunOptions.ts").SignalRunOptions} SignalRunOptions */
+
+/**
+ * @param {string} signalName
+ * @returns {string}
+ */
+function normalizeSignalName(signalName) {
+    const normalized = signalName.trim();
+    if (!normalized) {
+        throw new SmithersError("INVALID_INPUT", "Signal name must be a non-empty string.", { signalName });
+    }
+    return normalized;
+}
+/**
+ * @param {unknown} payload
+ * @returns {string}
+ */
+function serializeSignalPayload(payload) {
+    try {
+        const payloadJson = JSON.stringify(payload ?? null);
+        if (payloadJson === undefined) {
+            throw new Error("Signal payload serialized to undefined.");
+        }
+        return payloadJson;
+    }
+    catch (error) {
+        throw new SmithersError("INVALID_INPUT", "Signal payload must be valid JSON-serializable data.", undefined, { cause: error });
+    }
+}
+/**
+ * @param {SmithersDb} adapter
+ * @param {string} runId
+ * @param {string} signalName
+ * @param {unknown} payload
+ * @param {SignalRunOptions} [options]
+ * @returns {Effect.Effect<{ runId: string; seq: number; signalName: string; correlationId: string | null; receivedAtMs: number }, SmithersError, never>}
+ */
+export function signalRun(adapter, runId, signalName, payload, options = {}) {
+    const normalizedSignalName = normalizeSignalName(signalName);
+    const payloadJson = serializeSignalPayload(payload);
+    const receivedAtMs = options.timestampMs ?? nowMs();
+    return Effect.gen(function* () {
+        const run = yield* adapter.getRun(runId);
+        if (!run) {
+            throw new SmithersError("RUN_NOT_FOUND", `Run not found: ${runId}`, {
+                runId,
+            });
+        }
+        const seq = yield* adapter.insertSignalWithNextSeq({
+            runId,
+            signalName: normalizedSignalName,
+            correlationId: options.correlationId ?? null,
+            payloadJson,
+            receivedAtMs,
+            receivedBy: options.receivedBy ?? null,
+        });
+        const delivered = {
+            runId,
+            seq,
+            signalName: normalizedSignalName,
+            correlationId: options.correlationId ?? null,
+            receivedAtMs,
+        };
+        yield* Effect.promise(() => bridgeSignalResolve(adapter, runId, {
+            signalName: delivered.signalName,
+            correlationId: delivered.correlationId ?? null,
+            payloadJson,
+            seq: delivered.seq,
+            receivedAtMs: delivered.receivedAtMs,
+        }));
+        return delivered;
+    }).pipe(Effect.annotateLogs({
+        runId,
+        signalName: normalizedSignalName,
+        correlationId: options.correlationId ?? null,
+    }), Effect.withLogSpan("signal:send"));
+}