callman-core 1.32.0 → 1.33.0

package/dist/host/temporal/temporalService.js

@@ -0,0 +1,1182 @@
+// Temporal client service — the ONE implementation both hosts call (the
+// backend scenario worker and the desktop Electron main process), following
+// the db-adapter pattern: `@temporalio/client` is an optional dependency
+// loaded lazily, with a test seam to inject a fake driver.
+//
+// Responsibilities:
+// - build `Connection.connect(...)` options from a TemporalConnectionConfig
+//   (TLS / mTLS / Temporal Cloud API key / extra gRPC metadata);
+// - cache one Connection + Client per `${runId}:${connectionId}:${configHash}`
+//   so a scenario reuses the gRPC channel across nodes, released per run;
+// - execute one resolved operation and normalize its outcome into
+//   ScenarioTemporalResult (every key present);
+// - summarize an event history (event counts, activity timeline, signals,
+//   timers, failure) and decode payloads with the default data converter.
+//
+// Abort: the SDK offers no per-call cancellation. A cancelled wait closes and
+// evicts that cache entry, so a parallel branch sharing the connection simply
+// reconnects on its next call instead of touching a closed client.
+import { createHash } from "node:crypto";
+import { loadOptionalModule } from "../lazy.js";
+import { DEFAULT_TEMPORAL_HISTORY_LIMIT, DEFAULT_TEMPORAL_LIST_PAGE_SIZE, MAX_TEMPORAL_HISTORY_EVENTS, MAX_TEMPORAL_LIST_PAGE_SIZE, } from "../../scenario-runner/graphTraversal.js";
+import { createEmptyTemporalResult } from "../../scenario-runner/temporal.js";
+// --- Driver loading ---------------------------------------------------------
+let temporalDriverOverride = null;
+/**
+ * Test-only seam: inject a fake `@temporalio/client` module shape
+ * (`{ Connection, Client, ... }`) — core tests run under `node --test` with
+ * no module mocking. Never set in production.
+ */
+export const __setTemporalDriverForTests = (driver) => {
+    temporalDriverOverride = driver;
+};
+const loadTemporalDriver = async () => {
+    if (temporalDriverOverride) {
+        return temporalDriverOverride;
+    }
+    try {
+        const mod = await loadOptionalModule("@temporalio/client");
+        return mod && mod.default && !mod.Connection ? mod.default : mod;
+    }
+    catch {
+        throw new Error("Temporal client (`@temporalio/client`) is not installed. Install `@temporalio/client` to use Temporal connections.");
+    }
+};
+// --- Connection options -----------------------------------------------------
+const requireAddress = (config) => {
+    const address = (config.address ?? "").trim();
+    if (!address) {
+        throw new Error("Temporal connection has no address (host:port).");
+    }
+    return address;
+};
+export const resolveTemporalNamespace = (config, override) => (override ?? "").trim() || (config.namespace ?? "").trim() || "default";
+/** `Connection.connect` options for a connection config (secrets included). */
+export const buildTemporalConnectionOptions = (config) => {
+    const address = requireAddress(config);
+    const hasClientPair = Boolean(config.clientCert?.trim() && config.clientKey?.trim());
+    const useTls = config.tls === true || Boolean(config.apiKey?.trim()) || hasClientPair;
+    let tls = false;
+    if (useTls) {
+        const tlsOptions = {};
+        if (config.caCert?.trim()) {
+            tlsOptions.serverRootCACertificate = Buffer.from(config.caCert, "utf8");
+        }
+        if (hasClientPair) {
+            tlsOptions.clientCertPair = {
+                crt: Buffer.from(config.clientCert ?? "", "utf8"),
+                key: Buffer.from(config.clientKey ?? "", "utf8"),
+            };
+        }
+        if (config.serverNameOverride?.trim()) {
+            tlsOptions.serverNameOverride = config.serverNameOverride.trim();
+        }
+        tls = Object.keys(tlsOptions).length > 0 ? tlsOptions : true;
+    }
+    const metadata = {};
+    for (const [key, value] of Object.entries(config.metadata ?? {})) {
+        if (key.trim() && typeof value === "string") {
+            metadata[key.trim()] = value;
+        }
+    }
+    return {
+        address,
+        tls,
+        ...(config.apiKey?.trim() ? { apiKey: config.apiKey.trim() } : {}),
+        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
+        connectTimeout: typeof config.connectTimeoutMs === "number" && config.connectTimeoutMs > 0
+            ? Math.round(config.connectTimeoutMs)
+            : 10_000,
+    };
+};
+const clientCache = new Map();
+const hashConfig = (config) => createHash("sha1")
+    .update(JSON.stringify({
+    address: config.address,
+    namespace: config.namespace,
+    tls: config.tls ?? false,
+    caCert: config.caCert ?? "",
+    clientCert: config.clientCert ?? "",
+    clientKey: config.clientKey ?? "",
+    serverNameOverride: config.serverNameOverride ?? "",
+    apiKey: config.apiKey ?? "",
+    metadata: config.metadata ?? {},
+    identity: config.identity ?? "",
+}))
+    .digest("hex");
+const cacheKey = (runId, connectionId, config) => `${runId}:${connectionId}:${hashConfig(config)}`;
+const openClient = async (config, namespace) => {
+    const driver = await loadTemporalDriver();
+    const connection = await driver.Connection.connect(buildTemporalConnectionOptions(config));
+    const client = new driver.Client({
+        connection,
+        namespace,
+        ...(config.identity?.trim() ? { identity: config.identity.trim() } : {}),
+    });
+    return { connection, client, namespace };
+};
+const getCachedClient = async (runId, connectionId, config, namespace) => {
+    const key = `${cacheKey(runId, connectionId, config)}:${namespace}`;
+    let pending = clientCache.get(key);
+    if (!pending) {
+        pending = openClient(config, namespace);
+        clientCache.set(key, pending);
+        pending.catch(() => clientCache.delete(key));
+    }
+    return { key, entry: await pending };
+};
+const closeEntry = async (key) => {
+    const pending = clientCache.get(key);
+    clientCache.delete(key);
+    if (!pending) {
+        return;
+    }
+    try {
+        const entry = await pending;
+        await entry.connection.close?.();
+    }
+    catch {
+        // Already closed / never opened — nothing to release.
+    }
+};
+/** Close every connection opened under this scenario run. */
+export const releaseTemporalConnectionsForRun = async (runId) => {
+    const prefix = `${runId}:`;
+    await Promise.all([...clientCache.keys()].filter((key) => key.startsWith(prefix)).map((key) => closeEntry(key)));
+};
+/** Process shutdown: close everything. */
+export const closeAllTemporalConnections = async () => {
+    await Promise.all([...clientCache.keys()].map((key) => closeEntry(key)));
+};
+export const __getTemporalConnectionCountForTests = () => clientCache.size;
+// --- Payload / value helpers ------------------------------------------------
+const toIso = (value) => {
+    if (value === null || value === undefined)
+        return null;
+    if (value instanceof Date)
+        return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    if (typeof value === "string") {
+        const parsed = new Date(value);
+        return Number.isNaN(parsed.getTime()) ? value : parsed.toISOString();
+    }
+    if (typeof value === "number")
+        return new Date(value).toISOString();
+    // google.protobuf.Timestamp { seconds: Long|number, nanos }
+    if (typeof value === "object" && value !== null && "seconds" in value) {
+        const seconds = Number(value.seconds ?? 0);
+        const nanos = Number(value.nanos ?? 0);
+        if (Number.isFinite(seconds)) {
+            return new Date(seconds * 1000 + Math.floor(nanos / 1_000_000)).toISOString();
+        }
+    }
+    return null;
+};
+const toNumber = (value) => {
+    if (typeof value === "number")
+        return Number.isFinite(value) ? value : null;
+    if (typeof value === "bigint")
+        return Number(value);
+    if (typeof value === "string" && value.trim()) {
+        const parsed = Number(value);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    // Long.js { low, high, unsigned }
+    if (typeof value === "object" && value !== null && typeof value.toNumber === "function") {
+        const parsed = value.toNumber();
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    return null;
+};
+const durationToMs = (value) => {
+    if (value === null || value === undefined)
+        return null;
+    if (typeof value === "number")
+        return value;
+    // google.protobuf.Duration { seconds, nanos }
+    if (typeof value === "object" && "seconds" in value) {
+        const seconds = toNumber(value.seconds) ?? 0;
+        const nanos = toNumber(value.nanos) ?? 0;
+        return seconds * 1000 + Math.floor(nanos / 1_000_000);
+    }
+    return null;
+};
+const msToDuration = (ms) => typeof ms === "number" && ms > 0 ? `${Math.round(ms)}ms` : undefined;
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+// Strips the proto enum prefix: EVENT_TYPE_ACTIVITY_TASK_COMPLETED →
+// ActivityTaskCompleted; WORKFLOW_EXECUTION_STATUS_RUNNING → RUNNING.
+const enumName = (value, prefix) => {
+    if (typeof value === "number")
+        return null;
+    if (typeof value !== "string")
+        return null;
+    return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+};
+const toPascal = (upperSnake) => upperSnake
+    .toLowerCase()
+    .split("_")
+    .filter(Boolean)
+    .map((part) => part[0].toUpperCase() + part.slice(1))
+    .join("");
+const WORKFLOW_STATUS_BY_NUMBER = {
+    1: "RUNNING",
+    2: "COMPLETED",
+    3: "FAILED",
+    4: "CANCELED",
+    5: "TERMINATED",
+    6: "CONTINUED_AS_NEW",
+    7: "TIMED_OUT",
+};
+export const normalizeWorkflowStatus = (value) => {
+    if (typeof value === "number")
+        return WORKFLOW_STATUS_BY_NUMBER[value] ?? "UNKNOWN";
+    if (typeof value !== "string")
+        return "UNKNOWN";
+    const name = value.replace(/^WORKFLOW_EXECUTION_STATUS_/, "").toUpperCase();
+    const known = [
+        "RUNNING",
+        "COMPLETED",
+        "FAILED",
+        "CANCELED",
+        "TERMINATED",
+        "TIMED_OUT",
+        "CONTINUED_AS_NEW",
+    ];
+    return known.includes(name) ? name : "UNKNOWN";
+};
+const EVENT_TYPE_BY_NUMBER = {
+    1: "WorkflowExecutionStarted",
+    2: "WorkflowExecutionCompleted",
+    3: "WorkflowExecutionFailed",
+    4: "WorkflowExecutionTimedOut",
+    5: "WorkflowTaskScheduled",
+    6: "WorkflowTaskStarted",
+    7: "WorkflowTaskCompleted",
+    8: "WorkflowTaskTimedOut",
+    9: "WorkflowTaskFailed",
+    10: "ActivityTaskScheduled",
+    11: "ActivityTaskStarted",
+    12: "ActivityTaskCompleted",
+    13: "ActivityTaskFailed",
+    14: "ActivityTaskTimedOut",
+    15: "ActivityTaskCancelRequested",
+    16: "ActivityTaskCanceled",
+    17: "TimerStarted",
+    18: "TimerFired",
+    19: "TimerCanceled",
+    20: "WorkflowExecutionCancelRequested",
+    21: "WorkflowExecutionCanceled",
+    22: "RequestCancelExternalWorkflowExecutionInitiated",
+    23: "RequestCancelExternalWorkflowExecutionFailed",
+    24: "ExternalWorkflowExecutionCancelRequested",
+    25: "MarkerRecorded",
+    26: "WorkflowExecutionSignaled",
+    27: "WorkflowExecutionTerminated",
+    28: "WorkflowExecutionContinuedAsNew",
+    29: "StartChildWorkflowExecutionInitiated",
+    30: "StartChildWorkflowExecutionFailed",
+    31: "ChildWorkflowExecutionStarted",
+    32: "ChildWorkflowExecutionCompleted",
+    33: "ChildWorkflowExecutionFailed",
+    34: "ChildWorkflowExecutionCanceled",
+    35: "ChildWorkflowExecutionTimedOut",
+    36: "ChildWorkflowExecutionTerminated",
+    37: "SignalExternalWorkflowExecutionInitiated",
+    38: "SignalExternalWorkflowExecutionFailed",
+    39: "ExternalWorkflowExecutionSignaled",
+    40: "UpsertWorkflowSearchAttributes",
+    41: "WorkflowExecutionUpdateAccepted",
+    42: "WorkflowExecutionUpdateRejected",
+    43: "WorkflowExecutionUpdateCompleted",
+    44: "WorkflowPropertiesModifiedExternally",
+    45: "ActivityPropertiesModifiedExternally",
+    46: "WorkflowPropertiesModified",
+    47: "WorkflowExecutionUpdateAdmitted",
+    48: "NexusOperationScheduled",
+    49: "NexusOperationStarted",
+    50: "NexusOperationCompleted",
+    51: "NexusOperationFailed",
+    52: "NexusOperationCanceled",
+    53: "NexusOperationTimedOut",
+    54: "NexusOperationCancelRequested",
+    55: "WorkflowExecutionOptionsUpdated",
+};
+export const normalizeEventType = (value) => {
+    if (typeof value === "number")
+        return EVENT_TYPE_BY_NUMBER[value] ?? `EventType${value}`;
+    const name = enumName(value, "EVENT_TYPE_");
+    if (!name)
+        return "Unknown";
+    return /^[A-Z0-9_]+$/.test(name) ? toPascal(name) : name;
+};
+// Payload decoding: default data converter (JSON / null / binary). Anything
+// it cannot decode is kept as `{ encoding, data (base64) }` so the step never
+// fails on an exotic payload (custom data converters are not supported).
+let payloadConverter = null;
+const getPayloadConverter = async () => {
+    if (payloadConverter)
+        return payloadConverter;
+    try {
+        const driver = await loadTemporalDriver();
+        payloadConverter = driver.defaultPayloadConverter ?? null;
+    }
+    catch {
+        payloadConverter = null;
+    }
+    return payloadConverter;
+};
+const bytesToString = (value) => {
+    if (value instanceof Uint8Array)
+        return Buffer.from(value).toString("utf8");
+    if (typeof value === "string")
+        return Buffer.from(value, "base64").toString("utf8");
+    return null;
+};
+const decodeOnePayload = (payload, converter) => {
+    if (!isRecord(payload))
+        return payload;
+    if (converter && typeof converter.fromPayload === "function") {
+        try {
+            return converter.fromPayload(payload);
+        }
+        catch {
+            // fall through to the manual decode
+        }
+    }
+    const metadata = isRecord(payload.metadata) ? payload.metadata : {};
+    const encoding = bytesToString(metadata.encoding) ?? "unknown";
+    const data = payload.data;
+    if (encoding === "binary/null")
+        return null;
+    if (encoding === "json/plain" || encoding === "json/protobuf") {
+        const text = bytesToString(data);
+        if (text !== null) {
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+    }
+    const base64 = data instanceof Uint8Array
+        ? Buffer.from(data).toString("base64")
+        : typeof data === "string"
+            ? data
+            : null;
+    return { encoding, data: base64 };
+};
+/** Decode a `Payloads` ({ payloads: [...] }) or a single Payload into JS values. */
+export const decodeTemporalPayloads = async (value) => {
+    if (value === null || value === undefined)
+        return [];
+    const converter = await getPayloadConverter();
+    const list = isRecord(value) && Array.isArray(value.payloads) ? value.payloads : [value];
+    return list.map((entry) => decodeOnePayload(entry, converter));
+};
+const decodeFirst = async (value) => {
+    const decoded = await decodeTemporalPayloads(value);
+    return decoded.length === 0 ? null : decoded.length === 1 ? decoded[0] : decoded;
+};
+/** Decode a `{ fields: { key: Payload } }` map (memo / search attributes). */
+const decodeFieldMap = async (value) => {
+    if (!isRecord(value))
+        return null;
+    const fields = isRecord(value.fields) ? value.fields : value;
+    const converter = await getPayloadConverter();
+    const out = {};
+    for (const [key, payload] of Object.entries(fields)) {
+        out[key] = isRecord(payload) && "metadata" in payload ? decodeOnePayload(payload, converter) : payload;
+    }
+    return out;
+};
+// --- Failure mapping --------------------------------------------------------
+const failureTypeOf = (failure) => {
+    if (isRecord(failure.applicationFailureInfo)) {
+        const type = failure.applicationFailureInfo.type;
+        return typeof type === "string" && type ? type : "ApplicationFailure";
+    }
+    if (failure.activityFailureInfo)
+        return "ActivityFailure";
+    if (failure.childWorkflowExecutionFailureInfo)
+        return "ChildWorkflowFailure";
+    if (failure.canceledFailureInfo)
+        return "CanceledFailure";
+    if (failure.timeoutFailureInfo)
+        return "TimeoutFailure";
+    if (failure.terminatedFailureInfo)
+        return "TerminatedFailure";
+    if (failure.serverFailureInfo)
+        return "ServerFailure";
+    if (failure.nexusOperationExecutionFailureInfo)
+        return "NexusOperationFailure";
+    return null;
+};
+/** Proto `Failure` message → ScenarioTemporalFailure (cause chain flattened, depth 3). */
+export const summarizeProtoFailure = (value, depth = 0) => {
+    if (!isRecord(value))
+        return null;
+    const message = typeof value.message === "string" ? value.message : "Workflow failed";
+    const cause = [];
+    let current = value.cause;
+    let level = 0;
+    while (isRecord(current) && level < 3) {
+        cause.push({
+            message: typeof current.message === "string" ? current.message : "",
+            type: failureTypeOf(current),
+        });
+        current = current.cause;
+        level += 1;
+    }
+    return {
+        message,
+        type: failureTypeOf(value),
+        stackTrace: typeof value.stackTrace === "string" && value.stackTrace ? value.stackTrace : null,
+        ...(cause.length > 0 ? { cause } : {}),
+    };
+};
+/** SDK error (WorkflowFailedError, ApplicationFailure…) → ScenarioTemporalFailure. */
+export const summarizeSdkError = (error) => {
+    if (!(error instanceof Error)) {
+        return { message: String(error), type: null };
+    }
+    const cause = [];
+    let current = error.cause;
+    let level = 0;
+    while (current instanceof Error && level < 3) {
+        const typed = current;
+        cause.push({
+            message: current.message,
+            type: typeof typed.type === "string"
+                ? typed.type
+                : current.name && current.name !== "Error"
+                    ? current.name
+                    : null,
+        });
+        current = current.cause;
+        level += 1;
+    }
+    const first = cause[0];
+    return {
+        message: first?.message ? `${error.message}: ${first.message}` : error.message,
+        type: first?.type ?? (error.name !== "Error" ? error.name : null),
+        stackTrace: null,
+        ...(cause.length > 0 ? { cause } : {}),
+    };
+};
+const attributesOf = (event) => {
+    for (const [key, value] of Object.entries(event)) {
+        if (key.endsWith("EventAttributes") && isRecord(value)) {
+            return value;
+        }
+    }
+    return null;
+};
+const CLOSE_STATUS_BY_EVENT = {
+    WorkflowExecutionCompleted: "COMPLETED",
+    WorkflowExecutionFailed: "FAILED",
+    WorkflowExecutionTimedOut: "TIMED_OUT",
+    WorkflowExecutionCanceled: "CANCELED",
+    WorkflowExecutionTerminated: "TERMINATED",
+    WorkflowExecutionContinuedAsNew: "CONTINUED_AS_NEW",
+};
+/**
+ * Turn raw history events (proto JSON as `fetchHistory()` returns them) into
+ * the report-friendly summary. `eventTypes` filters the kept `events[]`
+ * (counts / activities / signals always cover the whole history); `limit`
+ * caps `events[]` (the last N events win — the tail is where failures are).
+ */
+export const summarizeTemporalHistory = async (rawEvents, options = {}) => {
+    const limit = Math.min(MAX_TEMPORAL_HISTORY_EVENTS, Math.max(1, options.limit ?? DEFAULT_TEMPORAL_HISTORY_LIMIT));
+    const wanted = new Set((options.eventTypes ?? []).map((entry) => entry.toLowerCase()));
+    const converter = await getPayloadConverter();
+    // The counters people assert on are zero-seeded so `equals 0` is a real
+    // check (a missing key would make the rule fail, not pass).
+    const eventCounts = {
+        WorkflowExecutionStarted: 0,
+        WorkflowExecutionCompleted: 0,
+        WorkflowExecutionFailed: 0,
+        WorkflowExecutionCanceled: 0,
+        WorkflowExecutionTerminated: 0,
+        WorkflowExecutionTimedOut: 0,
+        WorkflowExecutionSignaled: 0,
+        WorkflowTaskFailed: 0,
+        ActivityTaskScheduled: 0,
+        ActivityTaskStarted: 0,
+        ActivityTaskCompleted: 0,
+        ActivityTaskFailed: 0,
+        ActivityTaskTimedOut: 0,
+        ActivityTaskCanceled: 0,
+        TimerStarted: 0,
+        TimerFired: 0,
+        ChildWorkflowExecutionCompleted: 0,
+        ChildWorkflowExecutionFailed: 0,
+    };
+    const activitiesByScheduledId = new Map();
+    const activityOrder = [];
+    const signals = [];
+    const timersByStartedId = new Map();
+    const timerOrder = [];
+    let failure = null;
+    let result = null;
+    let status = null;
+    const kept = [];
+    for (const raw of rawEvents) {
+        if (!isRecord(raw))
+            continue;
+        const eventType = normalizeEventType(raw.eventType);
+        const eventId = toNumber(raw.eventId) ?? 0;
+        const eventTime = toIso(raw.eventTime);
+        const attributes = attributesOf(raw);
+        eventCounts[eventType] = (eventCounts[eventType] ?? 0) + 1;
+        switch (eventType) {
+            case "ActivityTaskScheduled": {
+                const activityType = isRecord(attributes?.activityType)
+                    ? String(attributes.activityType.name ?? "")
+                    : "";
+                const activity = {
+                    activityId: String(attributes?.activityId ?? eventId),
+                    activityType,
+                    status: "scheduled",
+                    attempt: 1,
+                    scheduledAt: eventTime,
+                    startedAt: null,
+                    closedAt: null,
+                    durationMs: null,
+                    failure: null,
+                };
+                activitiesByScheduledId.set(eventId, activity);
+                activityOrder.push(activity);
+                break;
+            }
+            case "ActivityTaskStarted": {
+                const activity = activitiesByScheduledId.get(toNumber(attributes?.scheduledEventId) ?? -1);
+                if (activity) {
+                    activity.status = "started";
+                    activity.startedAt = eventTime;
+                    activity.attempt = toNumber(attributes?.attempt) ?? activity.attempt;
+                    const lastFailure = summarizeProtoFailure(attributes?.lastFailure);
+                    if (lastFailure)
+                        activity.failure = lastFailure.message;
+                }
+                break;
+            }
+            case "ActivityTaskCompleted":
+            case "ActivityTaskFailed":
+            case "ActivityTaskTimedOut":
+            case "ActivityTaskCanceled": {
+                const activity = activitiesByScheduledId.get(toNumber(attributes?.scheduledEventId) ?? -1);
+                if (activity) {
+                    activity.status =
+                        eventType === "ActivityTaskCompleted"
+                            ? "completed"
+                            : eventType === "ActivityTaskFailed"
+                                ? "failed"
+                                : eventType === "ActivityTaskTimedOut"
+                                    ? "timed_out"
+                                    : "canceled";
+                    activity.closedAt = eventTime;
+                    const start = activity.startedAt ?? activity.scheduledAt;
+                    if (start && eventTime) {
+                        activity.durationMs = Math.max(0, Date.parse(eventTime) - Date.parse(start));
+                    }
+                    if (eventType === "ActivityTaskCompleted") {
+                        activity.result = attributes?.result ? decodeFirstSync(attributes.result, converter) : null;
+                    }
+                    else {
+                        const summarized = summarizeProtoFailure(attributes?.failure);
+                        if (summarized)
+                            activity.failure = summarized.message;
+                    }
+                }
+                break;
+            }
+            case "WorkflowExecutionSignaled": {
+                signals.push({
+                    name: String(attributes?.signalName ?? ""),
+                    eventId,
+                    eventTime,
+                });
+                break;
+            }
+            case "TimerStarted": {
+                const timer = {
+                    timerId: String(attributes?.timerId ?? eventId),
+                    fired: false,
+                    startedAt: eventTime,
+                };
+                timersByStartedId.set(eventId, timer);
+                timerOrder.push(timer);
+                break;
+            }
+            case "TimerFired": {
+                const timer = timersByStartedId.get(toNumber(attributes?.startedEventId) ?? -1);
+                if (timer)
+                    timer.fired = true;
+                break;
+            }
+            case "WorkflowExecutionCompleted": {
+                status = "COMPLETED";
+                result = attributes?.result ? decodeFirstSync(attributes.result, converter) : null;
+                break;
+            }
+            case "WorkflowExecutionFailed": {
+                status = "FAILED";
+                failure = summarizeProtoFailure(attributes?.failure) ?? { message: "Workflow failed", type: null };
+                break;
+            }
+            case "WorkflowExecutionTimedOut":
+            case "WorkflowExecutionCanceled":
+            case "WorkflowExecutionTerminated":
+            case "WorkflowExecutionContinuedAsNew": {
+                status = CLOSE_STATUS_BY_EVENT[eventType] ?? status;
+                if (eventType === "WorkflowExecutionTerminated" || eventType === "WorkflowExecutionCanceled") {
+                    const reason = typeof attributes?.reason === "string" ? attributes.reason : null;
+                    failure = {
+                        message: reason ? `${eventType.replace("WorkflowExecution", "")}: ${reason}` : eventType.replace("WorkflowExecution", "Workflow "),
+                        type: eventType === "WorkflowExecutionCanceled" ? "CanceledFailure" : "TerminatedFailure",
+                    };
+                }
+                else if (eventType === "WorkflowExecutionTimedOut") {
+                    failure = { message: "Workflow timed out", type: "TimeoutFailure" };
+                }
+                break;
+            }
+            default:
+                break;
+        }
+        if (wanted.size === 0 || wanted.has(eventType.toLowerCase())) {
+            kept.push({
+                eventId,
+                eventType,
+                eventTime,
+                ...(attributes ? { attributes: decodeAttributesSync(attributes, converter) } : {}),
+            });
+        }
+    }
+    if (status === null && rawEvents.length > 0) {
+        status = "RUNNING";
+    }
+    const truncated = kept.length > limit;
+    return {
+        events: truncated ? kept.slice(kept.length - limit) : kept,
+        eventCounts,
+        activities: activityOrder,
+        signals,
+        timers: timerOrder,
+        failure,
+        result,
+        status,
+        historyLength: rawEvents.length,
+        truncated,
+    };
+};
+const decodeFirstSync = (value, converter) => {
+    const list = isRecord(value) && Array.isArray(value.payloads) ? value.payloads : [value];
+    const decoded = list.map((entry) => decodeOnePayload(entry, converter));
+    return decoded.length === 0 ? null : decoded.length === 1 ? decoded[0] : decoded;
+};
+// Replace Payload(s) objects inside an attribute bag with decoded values so
+// the report shows `input: {...}` rather than base64 blobs. Shallow on purpose
+// — nested proto messages stay as they are.
+const decodeAttributesSync = (attributes, converter) => {
+    const out = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (isRecord(value) && Array.isArray(value.payloads)) {
+            out[key] = decodeFirstSync(value, converter);
+        }
+        else if (isRecord(value) && "metadata" in value && "data" in value) {
+            out[key] = decodeOnePayload(value, converter);
+        }
+        else if (key === "failure" || key === "lastFailure") {
+            out[key] = summarizeProtoFailure(value);
+        }
+        else if (typeof value === "bigint") {
+            out[key] = Number(value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+};
+// --- Abort plumbing ---------------------------------------------------------
+class TemporalAbortError extends Error {
+    constructor() {
+        super("Temporal operation cancelled");
+        this.name = "TemporalAbortError";
+    }
+}
+// Races a pending gRPC call against the scenario's abort signal. On abort the
+// cache entry is closed + evicted (the SDK has no per-call cancel).
+const raceAbort = async (task, signal, onAbort) => {
+    if (!signal)
+        return task;
+    if (signal.aborted) {
+        await onAbort();
+        throw new TemporalAbortError();
+    }
+    return await new Promise((resolve, reject) => {
+        const handleAbort = () => {
+            void onAbort().finally(() => reject(new TemporalAbortError()));
+        };
+        signal.addEventListener?.("abort", handleAbort, { once: true });
+        task.then((value) => {
+            signal.removeEventListener?.("abort", handleAbort);
+            resolve(value);
+        }, (error) => {
+            signal.removeEventListener?.("abort", handleAbort);
+            reject(error);
+        });
+    });
+};
+// --- Operation execution ----------------------------------------------------
+const workflowIdOf = (op) => {
+    if (!op.workflowId) {
+        throw new Error("Temporal operation needs a workflow id.");
+    }
+    return op.workflowId;
+};
+const toStartOptions = (op) => {
+    const start = op.startOptions;
+    return {
+        taskQueue: op.taskQueue,
+        workflowId: workflowIdOf(op),
+        args: op.args,
+        ...(start.idReusePolicy ? { workflowIdReusePolicy: start.idReusePolicy } : {}),
+        ...(start.idConflictPolicy ? { workflowIdConflictPolicy: start.idConflictPolicy } : {}),
+        ...(start.memo ? { memo: start.memo } : {}),
+        ...(start.searchAttributes ? { searchAttributes: start.searchAttributes } : {}),
+        ...(msToDuration(start.workflowExecutionTimeoutMs)
+            ? { workflowExecutionTimeout: msToDuration(start.workflowExecutionTimeoutMs) }
+            : {}),
+        ...(msToDuration(start.workflowRunTimeoutMs)
+            ? { workflowRunTimeout: msToDuration(start.workflowRunTimeoutMs) }
+            : {}),
+        ...(msToDuration(start.workflowTaskTimeoutMs)
+            ? { workflowTaskTimeout: msToDuration(start.workflowTaskTimeoutMs) }
+            : {}),
+        ...(msToDuration(start.startDelayMs) ? { startDelay: msToDuration(start.startDelayMs) } : {}),
+        ...(start.retryPolicy
+            ? {
+                retry: {
+                    ...(start.retryPolicy.maximumAttempts
+                        ? { maximumAttempts: start.retryPolicy.maximumAttempts }
+                        : {}),
+                    ...(msToDuration(start.retryPolicy.initialIntervalMs)
+                        ? { initialInterval: msToDuration(start.retryPolicy.initialIntervalMs) }
+                        : {}),
+                    ...(start.retryPolicy.backoffCoefficient
+                        ? { backoffCoefficient: start.retryPolicy.backoffCoefficient }
+                        : {}),
+                    ...(msToDuration(start.retryPolicy.maximumIntervalMs)
+                        ? { maximumInterval: msToDuration(start.retryPolicy.maximumIntervalMs) }
+                        : {}),
+                },
+            }
+            : {}),
+    };
+};
+const applyDescription = async (result, description) => {
+    // WorkflowExecutionDescription (SDK handle.describe()) — camelCase, with
+    // `raw` holding the proto DescribeWorkflowExecutionResponse.
+    result.workflowId = typeof description.workflowId === "string" ? description.workflowId : result.workflowId;
+    result.runId = typeof description.runId === "string" ? description.runId : result.runId;
+    result.status = normalizeWorkflowStatus(isRecord(description.status) ? description.status.name : description.status);
+    result.workflowType = typeof description.type === "string" ? description.type : result.workflowType;
+    result.taskQueue = typeof description.taskQueue === "string" ? description.taskQueue : result.taskQueue;
+    result.startTime = toIso(description.startTime);
+    result.closeTime = toIso(description.closeTime);
+    result.historyLength = toNumber(description.historyLength);
+    result.memo = isRecord(description.memo) ? description.memo : null;
+    result.searchAttributes = isRecord(description.searchAttributes)
+        ? description.searchAttributes
+        : isRecord(description.typedSearchAttributes)
+            ? description.typedSearchAttributes
+            : null;
+    const raw = isRecord(description.raw) ? description.raw : null;
+    const pending = raw && Array.isArray(raw.pendingActivities) ? raw.pendingActivities : [];
+    result.activities = pending.filter(isRecord).map((entry) => ({
+        activityId: String(entry.activityId ?? ""),
+        activityType: isRecord(entry.activityType) ? String(entry.activityType.name ?? "") : "",
+        status: String(entry.state ?? "").toUpperCase().includes("STARTED") ? "started" : "scheduled",
+        attempt: toNumber(entry.attempt) ?? 1,
+        scheduledAt: toIso(entry.scheduledTime),
+        startedAt: toIso(entry.lastStartedTime),
+        closedAt: null,
+        durationMs: null,
+        failure: summarizeProtoFailure(entry.lastFailure)?.message ?? null,
+    }));
+    const children = raw && Array.isArray(raw.pendingChildren) ? raw.pendingChildren : [];
+    result.pendingChildren = children.filter(isRecord).map((entry) => ({
+        workflowId: String(entry.workflowId ?? ""),
+        runId: typeof entry.runId === "string" ? entry.runId : null,
+        workflowType: typeof entry.workflowTypeName === "string" ? entry.workflowTypeName : null,
+    }));
+};
+const applyWorkflowFailure = (result, error) => {
+    const failure = summarizeSdkError(error);
+    result.failure = failure;
+    const type = (failure.type ?? "").toLowerCase();
+    const name = error instanceof Error ? error.name : "";
+    if (name === "WorkflowFailedError" || type.includes("application") || type.includes("activity")) {
+        result.status = type.includes("canceled")
+            ? "CANCELED"
+            : type.includes("terminated")
+                ? "TERMINATED"
+                : type.includes("timeout")
+                    ? "TIMED_OUT"
+                    : "FAILED";
+    }
+    else if (type.includes("canceled")) {
+        result.status = "CANCELED";
+    }
+    else if (type.includes("terminated")) {
+        result.status = "TERMINATED";
+    }
+    else if (type.includes("timeout")) {
+        result.status = "TIMED_OUT";
+    }
+    else {
+        result.status = "FAILED";
+    }
+};
+const isWorkflowClosedError = (error) => error instanceof Error &&
+    (error.name === "WorkflowFailedError" ||
+        error.name === "WorkflowCanceledError" ||
+        error.name === "WorkflowTerminatedError" ||
+        error.name === "WorkflowTimedOutError");
+const isNotFound = (error) => error instanceof Error &&
+    (error.name === "WorkflowNotFoundError" ||
+        /not found|NOT_FOUND/i.test(error.message));
+/**
+ * Execute one resolved Temporal operation. Throws for infrastructure /
+ * configuration errors (unreachable server, unknown workflow, rejected
+ * update…); a workflow that FAILED is a result (`status`, `failure`), not an
+ * exception — the node's `expect` rules decide what passes.
+ */
+export const executeTemporalOperation = async (input) => {
+    const config = input.connection.config;
+    const { op, runId, signal } = input;
+    const namespace = resolveTemporalNamespace(config, op.namespace);
+    const result = createEmptyTemporalResult(op.operation, namespace);
+    const startedAtMs = Date.now();
+    const { key, entry } = await getCachedClient(runId, input.connection.id, config, namespace);
+    const client = entry.client;
+    const abortClose = () => closeEntry(key);
+    const guarded = (task) => raceAbort(task, signal, abortClose);
+    const finish = () => {
+        result.durationMs = Date.now() - startedAtMs;
+        return result;
+    };
+    const handleFor = (workflowId, workflowRunId) => workflowRunId ? client.workflow.getHandle(workflowId, workflowRunId) : client.workflow.getHandle(workflowId);
+    const awaitHandleResult = async (handle) => {
+        try {
+            result.result = await guarded(handle.result());
+            result.status = "COMPLETED";
+        }
+        catch (error) {
+            if (error instanceof TemporalAbortError)
+                throw error;
+            if (isWorkflowClosedError(error)) {
+                applyWorkflowFailure(result, error);
+            }
+            else {
+                throw error;
+            }
+        }
+        try {
+            const description = await guarded(handle.describe());
+            if (isRecord(description)) {
+                const status = result.status;
+                await applyDescription(result, description);
+                // The describe status wins only when the SDK gave us nothing better.
+                if (status && result.status === "UNKNOWN")
+                    result.status = status;
+            }
+        }
+        catch {
+            // describe is best-effort after the result
+        }
+    };
+    switch (op.operation) {
+        case "startWorkflow": {
+            const workflowId = workflowIdOf(op);
+            let handle;
+            try {
+                handle = await guarded(client.workflow.start(op.workflowType, toStartOptions(op)));
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.name === "WorkflowExecutionAlreadyStartedError" &&
+                    op.startOptions.idConflictPolicy === "USE_EXISTING") {
+                    handle = client.workflow.getHandle(workflowId);
+                }
+                else {
+                    throw error;
+                }
+            }
+            result.workflowId = handle.workflowId ?? workflowId;
+            result.runId = typeof handle.firstExecutionRunId === "string" ? handle.firstExecutionRunId : null;
+            result.workflowType = op.workflowType;
+            result.taskQueue = op.taskQueue;
+            result.status = "RUNNING";
+            result.requested = true;
+            if (op.waitForResult) {
+                await awaitHandleResult(handle);
+            }
+            return finish();
+        }
+        case "signalWithStart": {
+            const handle = await guarded(client.workflow.signalWithStart(op.workflowType, {
+                ...toStartOptions(op),
+                signal: op.signalName,
+                signalArgs: op.signalArgs,
+            }));
+            result.workflowId = handle.workflowId ?? op.workflowId;
+            result.runId = typeof handle.firstExecutionRunId === "string" ? handle.firstExecutionRunId : null;
+            result.workflowType = op.workflowType;
+            result.taskQueue = op.taskQueue;
+            result.status = "RUNNING";
+            result.requested = true;
+            return finish();
+        }
+        case "signal": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            await guarded(handle.signal(op.signalName, ...op.args));
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            result.requested = true;
+            return finish();
+        }
+        case "query": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            result.result = await guarded(handle.query(op.queryName, ...op.args));
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            return finish();
+        }
+        case "update": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            if (op.waitForStage === "ACCEPTED") {
+                const updateHandle = await guarded(handle.startUpdate(op.updateName, { args: op.args, waitForStage: "ACCEPTED" }));
+                result.updateId = typeof updateHandle.updateId === "string" ? updateHandle.updateId : null;
+                result.requested = true;
+            }
+            else {
+                result.result = await guarded(handle.executeUpdate(op.updateName, { args: op.args }));
+                result.requested = true;
+            }
+            return finish();
+        }
+        case "awaitResult": {
+            const handle = handleFor(workflowIdOf(op), op.followRuns ? null : op.runId);
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            await awaitHandleResult(handle);
+            return finish();
+        }
+        case "describe": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            const description = await guarded(handle.describe());
+            if (isRecord(description)) {
+                await applyDescription(result, description);
+            }
+            return finish();
+        }
+        case "history": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            const history = await guarded(handle.fetchHistory());
+            const rawEvents = isRecord(history) && Array.isArray(history.events) ? history.events : [];
+            const summary = await summarizeTemporalHistory(rawEvents, {
+                eventTypes: op.eventTypes,
+                limit: op.historyLimit ?? undefined,
+            });
+            result.events = summary.events;
+            result.eventCounts = summary.eventCounts;
+            result.activities = summary.activities;
+            result.signals = summary.signals;
+            result.timers = summary.timers;
+            result.failure = summary.failure;
+            result.result = summary.result;
+            result.status = summary.status;
+            result.historyLength = summary.historyLength;
+            result.truncatedHistory = summary.truncated;
+            const first = rawEvents.find(isRecord);
+            const startAttributes = first ? attributesOf(first) : null;
+            if (startAttributes) {
+                result.workflowType = isRecord(startAttributes.workflowType)
+                    ? String(startAttributes.workflowType.name ?? "")
+                    : null;
+                result.taskQueue = isRecord(startAttributes.taskQueue)
+                    ? String(startAttributes.taskQueue.name ?? "")
+                    : null;
+                result.startTime = toIso(first?.eventTime);
+            }
+            return finish();
+        }
+        case "cancel":
+        case "terminate": {
+            const handle = handleFor(workflowIdOf(op), op.runId);
+            result.workflowId = op.workflowId;
+            result.runId = op.runId;
+            if (op.operation === "cancel") {
+                await guarded(handle.cancel());
+            }
+            else {
+                await guarded(handle.terminate(op.reason ?? undefined));
+            }
+            result.requested = true;
+            return finish();
+        }
+        case "list": {
+            const pageSize = Math.min(MAX_TEMPORAL_LIST_PAGE_SIZE, Math.max(1, op.pageSize ?? DEFAULT_TEMPORAL_LIST_PAGE_SIZE));
+            const executions = [];
+            const iterable = client.workflow.list({ query: op.query ?? "", pageSize });
+            const collect = (async () => {
+                for await (const info of iterable) {
+                    if (!isRecord(info))
+                        continue;
+                    executions.push({
+                        workflowId: String(info.workflowId ?? ""),
+                        runId: String(info.runId ?? ""),
+                        type: typeof info.type === "string" ? info.type : "",
+                        status: normalizeWorkflowStatus(isRecord(info.status) ? info.status.name : info.status),
+                        startTime: toIso(info.startTime),
+                        closeTime: toIso(info.closeTime),
+                        taskQueue: typeof info.taskQueue === "string" ? info.taskQueue : null,
+                    });
+                    if (executions.length >= pageSize)
+                        break;
+                }
+            })();
+            await guarded(collect);
+            result.executions = executions;
+            result.count = executions.length;
+            return finish();
+        }
+        case "count": {
+            const response = await guarded(client.workflow.count
+                ? client.workflow.count(op.query ?? "")
+                : entry.connection.workflowService.countWorkflowExecutions({
+                    namespace,
+                    query: op.query ?? "",
+                }));
+            result.count = toNumber(isRecord(response) ? response.count : response) ?? 0;
+            const groups = isRecord(response) && Array.isArray(response.groups) ? response.groups : [];
+            result.groups = groups.filter(isRecord).map((group) => ({
+                values: Array.isArray(group.groupValues)
+                    ? group.groupValues.map((value) => String(value ?? ""))
+                    : [],
+                count: toNumber(group.count) ?? 0,
+            }));
+            return finish();
+        }
+        case "describeTaskQueue": {
+            const response = await guarded(entry.connection.workflowService.describeTaskQueue({
+                namespace,
+                taskQueue: { name: op.taskQueue, kind: "TASK_QUEUE_KIND_NORMAL" },
+                taskQueueType: op.taskQueueType === "activity" ? "TASK_QUEUE_TYPE_ACTIVITY" : "TASK_QUEUE_TYPE_WORKFLOW",
+            }));
+            const pollers = isRecord(response) && Array.isArray(response.pollers) ? response.pollers : [];
+            result.taskQueue = op.taskQueue;
+            result.pollers = pollers.filter(isRecord).map((poller) => ({
+                identity: String(poller.identity ?? ""),
+                lastAccessTime: toIso(poller.lastAccessTime),
+                ratePerSecond: toNumber(poller.ratePerSecond),
+            }));
+            result.hasPollers = result.pollers.length > 0;
+            return finish();
+        }
+        default:
+            throw new Error(`Unsupported Temporal operation: ${String(op.operation)}`);
+    }
+};
+/** Map an SDK/gRPC error to the message the node reports. */
+export const describeTemporalError = (error, op) => {
+    if (error instanceof TemporalAbortError) {
+        return "Temporal operation cancelled";
+    }
+    if (!(error instanceof Error)) {
+        return String(error);
+    }
+    if (isNotFound(error) && op?.workflowId) {
+        return `Workflow not found: ${op.workflowId}${op.runId ? ` (run ${op.runId})` : ""}`;
+    }
+    const code = error.code;
+    if (code === 16 || /UNAUTHENTICATED/i.test(error.message)) {
+        return `Temporal rejected the credentials (UNAUTHENTICATED): ${error.message}`;
+    }
+    if (code === 14 || /UNAVAILABLE|ECONNREFUSED/i.test(error.message)) {
+        return `Temporal server unreachable (UNAVAILABLE): ${error.message}`;
+    }
+    if (error.name === "WorkflowUpdateFailedError") {
+        return `Workflow update rejected: ${summarizeSdkError(error).message}`;
+    }
+    if (error.name === "WorkflowExecutionAlreadyStartedError") {
+        return `Workflow already started: ${error.message}`;
+    }
+    return error.message;
+};
+// --- Connectivity check -----------------------------------------------------
+export const testTemporalConnection = async (config) => {
+    const startedAtMs = Date.now();
+    const namespace = resolveTemporalNamespace(config);
+    let connection = null;
+    try {
+        const driver = await loadTemporalDriver();
+        connection = await driver.Connection.connect(buildTemporalConnectionOptions(config));
+        let serverVersion = null;
+        try {
+            const info = await connection.workflowService.getSystemInfo({});
+            serverVersion = isRecord(info) && typeof info.serverVersion === "string" ? info.serverVersion : null;
+        }
+        catch {
+            serverVersion = null;
+        }
+        const described = await connection.workflowService.describeNamespace({ namespace });
+        const namespaceInfo = isRecord(described) && isRecord(described.namespaceInfo) ? described.namespaceInfo : null;
+        const stateRaw = namespaceInfo?.state;
+        const namespaceState = typeof stateRaw === "string"
+            ? toPascal(stateRaw.replace(/^NAMESPACE_STATE_/, ""))
+            : stateRaw === 1
+                ? "Registered"
+                : stateRaw === 2
+                    ? "Deprecated"
+                    : stateRaw === 3
+                        ? "Deleted"
+                        : null;
+        return {
+            ok: true,
+            serverVersion,
+            namespace,
+            namespaceState,
+            durationMs: Date.now() - startedAtMs,
+            message: null,
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            serverVersion: null,
+            namespace,
+            namespaceState: null,
+            durationMs: Date.now() - startedAtMs,
+            message: describeTemporalError(error),
+        };
+    }
+    finally {
+        try {
+            await connection?.close?.();
+        }
+        catch {
+            // ignore
+        }
+    }
+};
+//# sourceMappingURL=temporalService.js.map