@smthrs/gateway 0.35.0 → 1.0.0-rc.3

package/dist/cjs/EngineTrace.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Recorded native evidence, decoded through the contracts that wrote it.
+ *
+ * @since 1.0.0
+ */
+import * as EngineEvent from "@smthrs/journal/EngineEvent";
+import type { JournalRecord, TraceBuilder } from "./RunTrace.ts";
+/**
+ * A render-only view of the same decoded execution facts; never persisted.
+ *
+ * @category models
+ * @since 1.0.0
+ */
+export interface EngineExecutionEvidence {
+    readonly executionId: string;
+    readonly generation: number;
+    readonly spanId: string;
+    readonly parentExecutionId?: string | undefined;
+    readonly parentKnown: boolean;
+    readonly flowName?: string | undefined;
+    readonly input?: unknown | undefined;
+    readonly coherent: boolean;
+    /** Declared nodes, including work not reached at this journal cursor. */
+    readonly graph?: EngineEvent.NodeGraph | undefined;
+    readonly status: string;
+    /** Recorded clock and deferred registrations and their explicit settlements. */
+    readonly waits: ReadonlyArray<{
+        readonly id: string;
+        readonly kind: "sleep" | "signal";
+        readonly since: number;
+        readonly settledAt?: number;
+    }>;
+    readonly result?: {
+        readonly value: unknown;
+        readonly sequence: number;
+    } | undefined;
+    /** Original classified failure bytes, never parsed from rendered detail. */
+    readonly failure?: {
+        readonly kind: "cause" | "error" | "defect" | "interrupted" | "encoding";
+        readonly value: unknown;
+        readonly sequence: number;
+    } | undefined;
+}
+/**
+ * Observation completion is separate from the control run's terminal verdict.
+ *
+ * @category utilities
+ * @since 1.0.0
+ */
+export declare const engineProjectionPending: (records?: ReadonlyArray<JournalRecord>) => boolean;
+/**
+ * Folds native executions and attempts into trace spans with recorded ancestry.
+ *
+ * @category utilities
+ * @since 1.0.0
+ */
+export declare const engineTraceFromJournal: (records: ReadonlyArray<JournalRecord>) => Array<TraceBuilder>;
+/**
+ * Product claims use these typed facts, never text rendered into trace details.
+ *
+ * @category utilities
+ * @since 1.0.0
+ */
+export declare const engineExecutionEvidence: (records: ReadonlyArray<JournalRecord>) => ReadonlyArray<EngineExecutionEvidence>;
+/**
+ * Same recorded native ancestry and historical cursor for every product result projection.
+ *
+ * @category utilities
+ * @since 1.0.0
+ */
+export declare const engineRunEvidence: (records: ReadonlyArray<JournalRecord>, rootId: string, cursorSeq?: number) => {
+    executions: EngineExecutionEvidence[];
+    completed: EngineExecutionEvidence[];
+    belongs: (execution: EngineExecutionEvidence, ownerId?: string) => boolean;
+};
+//# sourceMappingURL=EngineTrace.d.ts.map

package/dist/cjs/EngineTrace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineTrace.d.ts","sourceRoot":"","sources":["../../src/EngineTrace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,WAAW,MAAM,6BAA6B,CAAA;AAI1D,OAAO,KAAK,EAAE,aAAa,EAAc,YAAY,EAAE,MAAM,eAAe,CAAA;AAgF5E;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC/C,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAA;IAC7B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IACtC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IACpC,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,yEAAyE;IACzE,QAAQ,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,SAAS,GAAG,SAAS,CAAA;IAClD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,gFAAgF;IAChF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,QAAQ,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;IAC9I,QAAQ,CAAC,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;IACpF,4EAA4E;IAC5E,QAAQ,CAAC,OAAO,CAAC,EAAE;QACjB,QAAQ,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,aAAa,GAAG,UAAU,CAAA;QACxE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;QACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;KAC1B,GAAG,SAAS,CAAA;CACd;AAOD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,UAAS,aAAa,CAAC,aAAa,CAAM,KAAG,OAqBpF,CAAA;AAuYD;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,SAAS,aAAa,CAAC,aAAa,CAAC,KAAG,KAAK,CAAC,YAAY,CAC/D,CAAA;AAElC;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAClC,SAAS,aAAa,CAAC,aAAa,CAAC,KACpC,aAAa,CAAC,uBAAuB,CAAwC,CAAA;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,SAAS,aAAa,CAAC,aAAa,CAAC,EAAE,QAAQ,MAAM,EAAE,YAAY,MAAM;;;yBAiB7E,uBAAuB,uBAAqB,OAAO;CAkBhF,CAAA"}

package/dist/cjs/EngineTrace.js

@@ -0,0 +1,501 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EngineTrace_exports = {};
+__export(EngineTrace_exports, {
+  engineExecutionEvidence: () => engineExecutionEvidence,
+  engineProjectionPending: () => engineProjectionPending,
+  engineRunEvidence: () => engineRunEvidence,
+  engineTraceFromJournal: () => engineTraceFromJournal
+});
+module.exports = __toCommonJS(EngineTrace_exports);
+var import_RunState = require("@smthrs/engine-store/RunState");
+var import_Flow = require("@smthrs/flow/Flow");
+var EngineEvent = __toESM(require("@smthrs/journal/EngineEvent"), 1);
+var JournalEvent = __toESM(require("@smthrs/journal/JournalEvent"), 1);
+var import_effect = require("effect");
+var import_inspectLabels = require("./internal/inspectLabels.js");
+const Envelope = import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  executionId: JournalEvent.RunId,
+  generation: JournalEvent.NonNegativeQuantity,
+  sequence: JournalEvent.Seq,
+  eventId: import_effect.Schema.String,
+  sourceId: JournalEvent.SourceId,
+  sourceSequence: JournalEvent.SourceSeq,
+  emittedAtMs: JournalEvent.TimestampMs,
+  eventType: import_effect.Schema.NonEmptyString,
+  payload: import_effect.Schema.Json,
+  meta: import_effect.Schema.Json
+});
+const decodeEnvelope = import_effect.Schema.decodeUnknownOption(Envelope);
+const decodeGraph = import_effect.Schema.decodeUnknownOption(EngineEvent.NodeGraph);
+const decodeScheduled = import_effect.Schema.decodeUnknownOption(EngineEvent.NodeScheduledPayload);
+const decodeSettled = import_effect.Schema.decodeUnknownOption(EngineEvent.NodeSettledPayload);
+const decodeAttempt = import_effect.Schema.decodeUnknownOption(EngineEvent.AttemptPayload, { onExcessProperty: "error" });
+const decodeState = import_effect.Schema.decodeUnknownOption(EngineEvent.StatePayload, { onExcessProperty: "error" });
+const decodeMarker = import_effect.Schema.decodeUnknownOption(EngineEvent.CurrentAttempt);
+const stateDecisions = [
+  "created",
+  "resumed",
+  "transitioned",
+  "handed-off",
+  "lineage-exhausted",
+  "round-invalid",
+  "quarantined",
+  "interrupt-released"
+];
+const decodeDecision = import_effect.Schema.decodeUnknownOption(import_effect.Schema.Struct({
+  decision: import_effect.Schema.Literals(stateDecisions),
+  status: import_effect.Schema.optionalKey(import_effect.Schema.Literals(["pending", "running", "suspended", "completed", "failed", "cancelled"])),
+  state: import_RunState.RunState
+}));
+const decodeCancellation = import_effect.Schema.decodeUnknownOption(import_effect.Schema.Struct({
+  outcome: import_effect.Schema.Literal("cancelled"),
+  interruptedAtMs: JournalEvent.TimestampMs,
+  owner: import_effect.Schema.String,
+  cascadedTo: import_effect.Schema.optionalKey(import_effect.Schema.Array(JournalEvent.RunId))
+}));
+const decodeResult = import_effect.Schema.decodeUnknownOption(import_Flow.ResultEncoded, { onExcessProperty: "error" });
+const json = (value) => typeof value === "string" ? value : JSON.stringify(value);
+const identity = (...parts) => parts.map((part) => encodeURIComponent(String(part))).join(":");
+const span = (id, kind, label, at, detail2) => ({
+  id,
+  kind,
+  label,
+  status: "recorded",
+  startedAt: at,
+  children: [],
+  detail: detail2
+});
+const detail = (row, envelope) => ({
+  sequence: row.sequence,
+  event: envelope.eventType,
+  fields: { ...envelope }
+});
+const decodeProjection = import_effect.Schema.decodeUnknownOption(import_effect.Schema.Struct({
+  version: import_effect.Schema.Literal(1),
+  executionId: JournalEvent.RunId,
+  generation: JournalEvent.NonNegativeQuantity
+}));
+const engineProjectionPending = (records = []) => {
+  const states = /* @__PURE__ */ new Map();
+  for (const row of [...records].sort((left, right) => (left.sequence ?? 0) - (right.sequence ?? 0))) {
+    if (row.kind === "control.engine.projection-gap") {
+      for (const state of states.values()) state.pending = false;
+      continue;
+    }
+    if (row.kind !== "control.engine.projection-started" && row.kind !== "control.engine.projection-settled") continue;
+    const decoded = decodeProjection(row.payload);
+    if (import_effect.Option.isNone(decoded)) continue;
+    const { executionId, generation } = decoded.value;
+    const current = states.get(executionId);
+    if (row.kind === "control.engine.projection-started") {
+      if (current === void 0 || generation > current.generation) {
+        states.set(executionId, { generation, pending: true });
+      }
+    } else if (current?.generation === generation) current.pending = false;
+  }
+  return [...states.values()].some((state) => state.pending);
+};
+const foldEngineJournal = (records) => {
+  const executions = /* @__PURE__ */ new Map();
+  const attempts = /* @__PURE__ */ new Map();
+  const notices = [];
+  const nodes = /* @__PURE__ */ new Map();
+  const instances = /* @__PURE__ */ new Map();
+  const seen = /* @__PURE__ */ new Map();
+  for (const row of records) {
+    if (row.kind === "control.engine.projection-gap") {
+      const notice = span(
+        `engine-gap:${row.sequence ?? notices.length}`,
+        "event",
+        "Engine evidence gap",
+        row.occurredAt ?? 0,
+        {
+          sequence: row.sequence,
+          event: row.kind,
+          fields: { evidence: row.payload }
+        }
+      );
+      notice.status = "unknown";
+      notice.endedAt = notice.startedAt;
+      notices.push(notice);
+      continue;
+    }
+    if (row.kind !== "control.engine.event") continue;
+    const decoded = decodeEnvelope(row.payload);
+    if (import_effect.Option.isNone(decoded)) {
+      const notice = span(
+        `engine-invalid:${row.sequence ?? notices.length}`,
+        "event",
+        "Unreadable engine evidence",
+        row.occurredAt ?? 0,
+        {
+          sequence: row.sequence,
+          event: row.kind,
+          fields: { evidence: row.payload }
+        }
+      );
+      notice.status = "unknown";
+      notice.endedAt = notice.startedAt;
+      notices.push(notice);
+      continue;
+    }
+    const envelope = decoded.value;
+    const key = identity(envelope.executionId, envelope.generation);
+    const eventKey = identity(key, envelope.sequence);
+    const previous = seen.get(eventKey);
+    if (previous !== void 0) {
+      if (previous !== JSON.stringify(envelope)) {
+        const conflict = executions.get(key);
+        conflict.coherent = false;
+      }
+      continue;
+    }
+    seen.set(eventKey, JSON.stringify(envelope));
+    let execution = executions.get(key);
+    if (execution === void 0) {
+      execution = {
+        envelope,
+        coherent: true,
+        span: span(`engine:${key}`, "execution", envelope.executionId, envelope.emittedAtMs, detail(row, envelope))
+      };
+      executions.set(key, execution);
+    }
+    const parent = (parentId) => {
+      if (execution.parentKnown && execution.parentExecutionId !== parentId) execution.coherent = false;
+      execution.parentKnown = true;
+      execution.parentExecutionId = parentId;
+      execution.parentId = parentId;
+    };
+    const result = (value) => {
+      if (Number.isSafeInteger(row.sequence) && row.sequence >= 0) {
+        execution.result = { value, sequence: row.sequence };
+      }
+    };
+    const failure = (kind, value) => {
+      if (Number.isSafeInteger(row.sequence) && row.sequence >= 0) {
+        execution.failure = { kind, value, sequence: row.sequence };
+      }
+    };
+    const generic = () => {
+      const event = span(
+        `engine-event:${eventKey}`,
+        "event",
+        envelope.eventType,
+        envelope.emittedAtMs,
+        detail(row, envelope)
+      );
+      event.endedAt = event.startedAt;
+      execution.span.children.push(event);
+    };
+    const attempt = (step, number) => {
+      const attemptKey = identity(key, step, number);
+      let current = attempts.get(attemptKey);
+      if (current === void 0) {
+        current = span(
+          `engine-attempt:${attemptKey}`,
+          "attempt",
+          `attempt ${number} \xB7 ${step.slice(0, 12)}`,
+          envelope.emittedAtMs,
+          detail(row, envelope)
+        );
+        attempts.set(attemptKey, current);
+        execution.span.children.push(current);
+      }
+      return current;
+    };
+    if (envelope.eventType === EngineEvent.nodeEventTypes.planRecorded || envelope.eventType === EngineEvent.nodeEventTypes.subgraphAppended) {
+      const payload = envelope.payload;
+      const graph = decodeGraph(payload?.graph);
+      if (import_effect.Option.isSome(graph)) {
+        const nodes2 = new Map(execution.graph?.nodes.map((node) => [node.id, node]));
+        for (const node of graph.value.nodes) nodes2.set(node.id, node);
+        execution.graph = { ...graph.value, nodes: [...nodes2.values()] };
+      }
+      generic();
+      continue;
+    }
+    if (envelope.eventType === EngineEvent.nodeEventTypes.nodeScheduled || envelope.eventType === EngineEvent.nodeEventTypes.nodeSettled) {
+      const scheduled = envelope.eventType === EngineEvent.nodeEventTypes.nodeScheduled ? decodeScheduled(envelope.payload) : import_effect.Option.none();
+      const settled = envelope.eventType === EngineEvent.nodeEventTypes.nodeSettled ? decodeSettled(envelope.payload) : import_effect.Option.none();
+      const recorded = import_effect.Option.isSome(scheduled) ? scheduled.value : import_effect.Option.isSome(settled) ? settled.value : void 0;
+      if (recorded === void 0) {
+        generic();
+        continue;
+      }
+      const nodeKey = identity(key, recorded.nodeId);
+      const action = recorded.action ?? execution.graph?.nodes.find((node2) => node2.id === recorded.nodeId)?.action;
+      let node = nodes.get(nodeKey);
+      if (node === void 0 || import_effect.Option.isSome(scheduled)) {
+        const instance = (instances.get(nodeKey) ?? 0) + 1;
+        instances.set(nodeKey, instance);
+        node = span(`engine-node:${nodeKey}#${instance}`, "call", (0, import_inspectLabels.inspectLabel)(action ?? recorded.nodeId), envelope.emittedAtMs, detail(row, envelope));
+        nodes.set(nodeKey, node);
+        execution.span.children.push(node);
+      }
+      if (action !== void 0) node.label = (0, import_inspectLabels.inspectLabel)(action);
+      node.detail = { ...detail(row, envelope), sequence: node.detail.sequence };
+      if (import_effect.Option.isSome(scheduled)) {
+        node.status = "running";
+      } else {
+        const value = import_effect.Option.getOrThrow(settled);
+        node.status = value.outcome === "failed" ? "failed" : value.outcome === "deferred" ? "waiting" : value.outcome === "skipped" ? "skipped" : "completed";
+        if (value.outcome !== "deferred") node.endedAt = envelope.emittedAtMs;
+        if (value.result !== void 0) node.detail = { ...node.detail, output: value.result.preview };
+      }
+      continue;
+    }
+    if (envelope.eventType === "flows.engine.attempt-started" || envelope.eventType === "flows.engine.attempt-finished") {
+      const marker = decodeMarker({ eventType: envelope.eventType, payload: envelope.payload });
+      if (import_effect.Option.isNone(marker) || marker.value.payload.runId !== envelope.executionId) {
+        generic();
+        continue;
+      }
+      const current = attempt(marker.value.payload.stepKeyDigest, marker.value.payload.attempt);
+      if (marker.value.eventType === "flows.engine.attempt-started") current.status = "running";
+      else {
+        current.status = marker.value.payload.state === "succeeded" ? "completed" : "failed";
+        current.endedAt = envelope.emittedAtMs;
+      }
+      current.detail = { ...current.detail, fields: { ...envelope } };
+      continue;
+    }
+    if (envelope.eventType === EngineEvent.attemptEventType) {
+      const recorded = decodeAttempt(envelope.payload);
+      if (import_effect.Option.isNone(recorded) || recorded.value.executionId !== envelope.executionId) {
+        execution.coherent = false;
+        generic();
+        continue;
+      }
+      const { lifecycle, lineage, stepKeyDigest, attempt: number } = recorded.value;
+      execution.parentId = lineage.parentRunId ?? void 0;
+      const current = attempt(stepKeyDigest, number);
+      current.startedAt = lifecycle.startedAtMs;
+      current.status = lifecycle.state === "succeeded" ? "completed" : lifecycle.state === "suspended" ? "waiting" : lifecycle.state;
+      current.detail = { ...detail(row, envelope), sequence: current.detail.sequence };
+      if (lifecycle.state === "succeeded" || lifecycle.state === "failed") {
+        current.endedAt = lifecycle.finishedAtMs;
+        current.detail = {
+          ...current.detail,
+          ...lifecycle.result._tag === "Success" ? { output: json(lifecycle.result.value) } : { message: json(lifecycle.result.detail) }
+        };
+      }
+      continue;
+    }
+    if (envelope.eventType === EngineEvent.stateEventType) {
+      const recorded = decodeState(envelope.payload);
+      if (import_effect.Option.isNone(recorded) || recorded.value.executionId !== envelope.executionId) {
+        execution.coherent = false;
+        generic();
+        continue;
+      }
+      execution.parentId = recorded.value.lineage.parentRunId ?? void 0;
+      const registerWait = (waitId, kind) => {
+        const waits = execution.waits ??= /* @__PURE__ */ new Map();
+        const id = identity(key, waitId);
+        const existing = waits.get(id);
+        if (existing === void 0) waits.set(id, { id: `engine-wait:${id}`, kind, since: envelope.emittedAtMs });
+        else if (kind === "sleep") existing.kind = kind;
+      };
+      if (recorded.value.event._tag === "Execution" && recorded.value.event.lifecycle.state !== "completed") {
+        for (const wait of recorded.value.event.lifecycle.waits) registerWait(wait.waitId, wait._tag === "Clock" ? "sleep" : "signal");
+      }
+      if (recorded.value.event._tag === "ClockScheduled") {
+        registerWait(recorded.value.event.waitId, "sleep");
+      } else if (recorded.value.event._tag === "DeferredCompleted") {
+        const wait = execution.waits?.get(identity(key, recorded.value.event.waitId));
+        if (wait !== void 0 && wait.settledAt === void 0) wait.settledAt = envelope.emittedAtMs;
+      }
+      if (recorded.value.event._tag !== "Execution") {
+        generic();
+        continue;
+      }
+      const { lifecycle } = recorded.value.event;
+      execution.result = void 0;
+      execution.failure = void 0;
+      execution.span.detail = {
+        ...detail(row, envelope),
+        sequence: execution.span.detail.sequence,
+        input: execution.span.detail.input
+      };
+      if (lifecycle.state === "completed") {
+        execution.span.status = lifecycle.result._tag === "Success" ? "completed" : "failed";
+        execution.span.endedAt = envelope.emittedAtMs;
+        execution.span.detail = {
+          ...execution.span.detail,
+          ...lifecycle.result._tag === "Success" ? { output: json(lifecycle.result.value) } : { message: json(lifecycle.result.detail) }
+        };
+        if (lifecycle.result._tag === "Success") result(lifecycle.result.value);
+        else failure(lifecycle.result.reason, lifecycle.result.detail);
+      } else execution.span.status = lifecycle.state === "suspended" ? "waiting" : "running";
+      continue;
+    }
+    if (envelope.eventType === "flows.engine.interrupted") {
+      const cancelled = decodeCancellation(envelope.payload);
+      if (import_effect.Option.isNone(cancelled)) {
+        generic();
+        continue;
+      }
+      execution.result = void 0;
+      execution.failure = void 0;
+      execution.span.status = "cancelled";
+      execution.span.endedAt = cancelled.value.interruptedAtMs;
+      execution.span.detail = {
+        ...detail(row, envelope),
+        sequence: execution.span.detail.sequence,
+        input: execution.span.detail.input
+      };
+      continue;
+    }
+    if (envelope.eventType === "flows.engine.run-decision") {
+      const decision = decodeDecision(envelope.payload);
+      if (import_effect.Option.isNone(decision)) {
+        const payload = envelope.payload;
+        if (typeof payload === "object" && payload !== null && ("state" in payload || "decision" in payload && stateDecisions.some((name) => name === payload.decision))) {
+          execution.coherent = false;
+        }
+        generic();
+        continue;
+      }
+      const { state, status } = decision.value;
+      if (execution.flowName !== void 0 && execution.flowName !== state.flowName) execution.coherent = false;
+      execution.flowName = state.flowName;
+      execution.span.label = (0, import_inspectLabels.inspectLabel)(state.flowName);
+      parent(state.parentExecutionId);
+      execution.result = void 0;
+      execution.failure = void 0;
+      execution.span.detail = {
+        ...detail(row, envelope),
+        sequence: execution.span.detail.sequence,
+        input: state.payload
+      };
+      if (decision.value.decision === "created") execution.span.status = "pending";
+      else if (decision.value.decision === "interrupt-released") execution.span.status = "waiting";
+      else if (status === "running" || status === "pending" || status === "suspended") {
+        execution.span.status = status === "suspended" ? "waiting" : status;
+      } else if (status !== void 0) {
+        const decodedResult = decodeResult(state.result);
+        if (import_effect.Option.isSome(decodedResult) && decodedResult.value._tag === "Handoff" && status === "completed" && decision.value.decision === "handed-off") {
+          execution.span.status = "completed";
+          execution.span.endedAt = envelope.emittedAtMs;
+          continue;
+        }
+        if (import_effect.Option.isNone(decodedResult) || decodedResult.value._tag !== "Complete" || status === "completed" !== (decodedResult.value.exit._tag === "Success")) {
+          execution.coherent = false;
+          execution.span.status = "unknown";
+          generic();
+          continue;
+        }
+        execution.span.status = status;
+        execution.span.endedAt = envelope.emittedAtMs;
+        execution.span.detail = {
+          ...execution.span.detail,
+          ...decodedResult.value.exit._tag === "Success" ? { output: json(decodedResult.value.exit.value) } : { message: json(decodedResult.value.exit.cause) }
+        };
+        if (decodedResult.value.exit._tag === "Success") result(decodedResult.value.exit.value);
+        else failure("cause", decodedResult.value.exit.cause);
+      }
+      continue;
+    }
+    generic();
+  }
+  const byExecution = /* @__PURE__ */ new Map();
+  for (const current of executions.values()) {
+    const generations = byExecution.get(current.envelope.executionId) ?? [];
+    generations.push(current);
+    byExecution.set(current.envelope.executionId, generations);
+  }
+  const roots = [];
+  for (const current of executions.values()) {
+    const parents = current.parentId === void 0 ? [] : byExecution.get(current.parentId) ?? [];
+    const ancestors = /* @__PURE__ */ new Set([current.envelope.executionId]);
+    let parent = parents.length === 1 ? parents[0] : void 0;
+    let cursor = parent;
+    while (cursor !== void 0) {
+      if (ancestors.has(cursor.envelope.executionId)) {
+        parent = void 0;
+        break;
+      }
+      ancestors.add(cursor.envelope.executionId);
+      const next = cursor.parentId === void 0 ? [] : byExecution.get(cursor.parentId) ?? [];
+      cursor = next.length === 1 ? next[0] : void 0;
+    }
+    if (parent === void 0) roots.push(current.span);
+    else parent.span.children.push(current.span);
+  }
+  const evidence = [...executions.values()].map((current) => ({
+    executionId: current.envelope.executionId,
+    generation: current.envelope.generation,
+    spanId: current.span.id,
+    parentExecutionId: current.parentExecutionId,
+    parentKnown: current.parentKnown === true,
+    flowName: current.flowName,
+    input: current.span.detail.input,
+    coherent: current.coherent,
+    graph: current.graph,
+    status: current.span.status,
+    waits: [...current.waits?.values() ?? []],
+    result: current.result,
+    failure: current.failure
+  }));
+  return { trace: [...roots, ...notices], evidence };
+};
+const engineTraceFromJournal = (records) => foldEngineJournal(records).trace;
+const engineExecutionEvidence = (records) => foldEngineJournal(records).evidence;
+const engineRunEvidence = (records, rootId, cursorSeq) => {
+  const visible = records.filter(
+    (row) => Number.isSafeInteger(row.sequence) && Number(row.sequence) >= 0 && (cursorSeq === void 0 || Number(row.sequence) <= cursorSeq)
+  ).sort((left, right) => Number(left.sequence) - Number(right.sequence));
+  const executions = engineExecutionEvidence(visible);
+  const generations = /* @__PURE__ */ new Map();
+  for (const execution of executions) {
+    const found = generations.get(execution.executionId) ?? [];
+    found.push(execution);
+    generations.set(execution.executionId, found);
+  }
+  const current = (execution) => execution.coherent && execution.generation === Math.max(...generations.get(execution.executionId).map((row) => row.generation));
+  const belongs = (execution, ownerId = rootId) => {
+    const visited = /* @__PURE__ */ new Set();
+    let candidate = execution;
+    while (true) {
+      if (!candidate.coherent || !candidate.parentKnown || visited.has(candidate.executionId)) return false;
+      visited.add(candidate.executionId);
+      if (candidate.executionId === ownerId) return ownerId !== rootId || candidate.parentExecutionId === void 0;
+      if (candidate.parentExecutionId === void 0) return false;
+      const parents = generations.get(candidate.parentExecutionId) ?? [];
+      if (parents.length !== 1) return false;
+      candidate = parents[0];
+    }
+  };
+  const owned = executions.filter((row) => current(row) && belongs(row));
+  const completed = owned.filter((row) => row.status === "completed" && row.result !== void 0);
+  return { executions: owned, completed, belongs };
+};
+//# sourceMappingURL=EngineTrace.js.map