temporal-explorer 0.0.0-mvp

package/dist/api/index.js

@@ -0,0 +1,4322 @@
+// @bun
+// packages/analyzer/src/index.ts
+import { basename, resolve as resolve3 } from "path";
+import { Project } from "ts-morph";
+
+// packages/analyzer/src/configuration.ts
+var severityOverrides = new Set(["error", "warning", "info", "off"]);
+function assertStringArray(value, label) {
+  if (value !== undefined && (!Array.isArray(value) || value.some((entry) => typeof entry !== "string"))) {
+    throw new Error(`temporal-explorer.config.ts: ${label} must be an array of strings.`);
+  }
+}
+function assertDiagnosticOverrides(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("temporal-explorer.config.ts: diagnostics must map diagnostic codes to severities.");
+  }
+  for (const [code, severity] of Object.entries(value)) {
+    if (typeof severity !== "string" || !severityOverrides.has(severity)) {
+      throw new Error(`temporal-explorer.config.ts: diagnostics.${code} must be error, warning, info, or off.`);
+    }
+  }
+}
+function defineConfig(configuration) {
+  if (typeof configuration !== "object" || configuration === null) {
+    throw new Error("temporal-explorer.config.ts must export a configuration object.");
+  }
+  assertStringArray(configuration.include, "include");
+  assertStringArray(configuration.exclude, "exclude");
+  assertStringArray(configuration.temporal?.workflowGlobs, "temporal.workflowGlobs");
+  assertStringArray(configuration.temporal?.workerGlobs, "temporal.workerGlobs");
+  assertStringArray(configuration.temporal?.clientGlobs, "temporal.clientGlobs");
+  assertDiagnosticOverrides(configuration.diagnostics);
+  return configuration;
+}
+async function loadConfiguration(configPath) {
+  if (!await Bun.file(configPath).exists()) {
+    return;
+  }
+  const module = await import(configPath);
+  if (!module.default || typeof module.default !== "object") {
+    throw new Error(`${configPath} must default-export defineConfig(...).`);
+  }
+  return defineConfig(module.default);
+}
+function applySeverityOverrides(diagnostics, overrides) {
+  if (!overrides) {
+    return diagnostics;
+  }
+  const applied = [];
+  for (const diagnostic of diagnostics) {
+    const override = overrides[diagnostic.code];
+    if (override === "off") {
+      continue;
+    }
+    applied.push(override ? { ...diagnostic, severity: override } : diagnostic);
+  }
+  return applied;
+}
+
+// packages/analyzer/src/package-metadata.ts
+import { resolve } from "path";
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readStringRecord(value) {
+  if (!isRecord(value)) {
+    return;
+  }
+  const entries = Object.entries(value).filter((entry) => typeof entry[1] === "string");
+  return Object.fromEntries(entries);
+}
+async function readPackageJson(root) {
+  const packagePath = resolve(root, "package.json");
+  const file = Bun.file(packagePath);
+  if (!await file.exists()) {
+    return {};
+  }
+  const value = await file.json();
+  if (!isRecord(value)) {
+    return {};
+  }
+  const metadata = {};
+  const dependencies = readStringRecord(value["dependencies"]);
+  const devDependencies = readStringRecord(value["devDependencies"]);
+  if (typeof value["packageManager"] === "string") {
+    metadata.packageManager = value["packageManager"];
+  }
+  if (dependencies) {
+    metadata.dependencies = dependencies;
+  }
+  if (devDependencies) {
+    metadata.devDependencies = devDependencies;
+  }
+  return metadata;
+}
+function getPackageManager(packageJson) {
+  const packageManager = packageJson.packageManager?.split("@")[0];
+  if (packageManager === "bun" || packageManager === "npm" || packageManager === "pnpm" || packageManager === "yarn") {
+    return packageManager;
+  }
+  return;
+}
+
+// packages/analyzer/src/paths.ts
+import { relative, resolve as resolve2 } from "path";
+function toProjectPath(root, path) {
+  return relative(root, path).split("\\").join("/");
+}
+function createSourceLocation(root, sourceFile, node, symbolName) {
+  const startOffset = node.getStart();
+  const endOffset = node.getEnd();
+  const start = sourceFile.getLineAndColumnAtPos(startOffset);
+  const end = sourceFile.getLineAndColumnAtPos(endOffset);
+  const baseLocation = {
+    path: toProjectPath(root, sourceFile.getFilePath()),
+    pathKind: "project-relative",
+    start: {
+      line: start.line,
+      column: start.column,
+      offset: startOffset
+    },
+    end: {
+      line: end.line,
+      column: end.column,
+      offset: endOffset
+    }
+  };
+  return symbolName ? { ...baseLocation, symbolName } : baseLocation;
+}
+async function hashFile(path) {
+  const file = Bun.file(path);
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(await file.arrayBuffer());
+  return hasher.digest("hex");
+}
+async function createSourceFileHashes(root, files) {
+  const entries = await Promise.all(files.map(async (file) => [toProjectPath(root, file), await hashFile(file)]));
+  return Object.fromEntries(entries.toSorted(([left], [right]) => left.localeCompare(right)));
+}
+async function discoverFiles(root, globs) {
+  const discovered = new Set;
+  for (const pattern of globs) {
+    const glob = new Bun.Glob(pattern);
+    for await (const relativePath of glob.scan({ cwd: root, onlyFiles: true })) {
+      if (!relativePath.endsWith(".test.ts") && !relativePath.endsWith(".spec.ts")) {
+        discovered.add(resolve2(root, relativePath));
+      }
+    }
+  }
+  return [...discovered].toSorted((left, right) => left.localeCompare(right));
+}
+
+// packages/analyzer/src/workflow-analysis.ts
+import {
+  Node as Node8,
+  SyntaxKind as SyntaxKind7
+} from "ts-morph";
+
+// packages/analyzer/src/determinism-diagnostics.ts
+import { SyntaxKind as SyntaxKind4 } from "ts-morph";
+
+// packages/analyzer/src/workflow-messages.ts
+import {
+  Node as Node2,
+  SyntaxKind as SyntaxKind2
+} from "ts-morph";
+
+// packages/analyzer/src/symbols.ts
+import {
+  Node,
+  SyntaxKind
+} from "ts-morph";
+var temporalWorkflowModule = "@temporalio/workflow";
+var temporalWorkerModule = "@temporalio/worker";
+function isWorkflowModuleCall(call, importedName) {
+  const expression = call.getExpression();
+  return Node.isIdentifier(expression) && isNamedImportFrom(expression, temporalWorkflowModule, importedName);
+}
+function isNamedImportFrom(identifier, moduleSpecifier, importedName) {
+  const symbol = identifier.getSymbol();
+  return symbol?.getDeclarations().some((declaration) => {
+    if (!Node.isImportSpecifier(declaration)) {
+      return false;
+    }
+    const importDeclaration = declaration.getImportDeclaration();
+    const exportedName = declaration.compilerNode.propertyName?.getText() ?? declaration.getNameNode().getText();
+    return importDeclaration.getModuleSpecifierValue() === moduleSpecifier && exportedName === importedName;
+  }) ?? false;
+}
+function isProxyActivitiesCall(call) {
+  const expression = call.getExpression();
+  return Node.isIdentifier(expression) && isNamedImportFrom(expression, temporalWorkflowModule, "proxyActivities");
+}
+function unwrapCasts(node) {
+  let current = node;
+  while (Node.isAsExpression(current) || Node.isParenthesizedExpression(current)) {
+    current = current.getExpression();
+  }
+  return current;
+}
+function findActivityProxyVariables(sourceFile) {
+  const proxyVariables = new Set;
+  for (let pass = 0;pass < 2; pass += 1) {
+    for (const declaration of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+      const nameNode = declaration.getNameNode();
+      const initializer = declaration.getInitializer();
+      if (!initializer || !Node.isIdentifier(nameNode)) {
+        continue;
+      }
+      const unwrapped = unwrapCasts(initializer);
+      if (Node.isCallExpression(unwrapped) && isProxyActivitiesCall(unwrapped)) {
+        proxyVariables.add(nameNode.getText());
+      } else if (Node.isIdentifier(unwrapped) && proxyVariables.has(unwrapped.getText())) {
+        proxyVariables.add(nameNode.getText());
+      }
+    }
+  }
+  return proxyVariables;
+}
+function isProxySourceExpression(node, proxyVariables) {
+  const unwrapped = unwrapCasts(node);
+  return Node.isCallExpression(unwrapped) && isProxyActivitiesCall(unwrapped) || Node.isIdentifier(unwrapped) && proxyVariables.has(unwrapped.getText());
+}
+function collectBindingElements(pattern, bindings) {
+  for (const element of pattern.getElements()) {
+    const localNameNode = element.getNameNode();
+    if (Node.isIdentifier(localNameNode)) {
+      const activityName = element.getPropertyNameNode()?.getText() ?? localNameNode.getText();
+      bindings.set(localNameNode.getText(), activityName);
+    }
+  }
+}
+function findDestructuredActivityBindings(sourceFile, proxyVariables) {
+  const bindings = new Map;
+  for (const declaration of sourceFile.getDescendantsOfKind(SyntaxKind.VariableDeclaration)) {
+    const nameNode = declaration.getNameNode();
+    const initializer = declaration.getInitializer();
+    if (initializer && Node.isObjectBindingPattern(nameNode) && isProxySourceExpression(initializer, proxyVariables)) {
+      collectBindingElements(nameNode, bindings);
+    }
+  }
+  return bindings;
+}
+
+// packages/analyzer/src/type-shapes.ts
+function createTypeShape(id, display, source, displayName) {
+  return {
+    id,
+    display,
+    ...displayName ? { displayName } : {},
+    kind: display === "void" ? "primitive" : "external",
+    ...source ? { source } : {},
+    confidence: display === "unknown" ? "unknown" : "exact"
+  };
+}
+
+// packages/analyzer/src/tuple-shapes.ts
+var nestingOpeners = new Set(["<", "[", "{", "("]);
+var nestingClosers = new Set([">", "]", "}", ")"]);
+function splitTopLevel(contents) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const character of contents) {
+    if (nestingOpeners.has(character)) {
+      depth += 1;
+    } else if (nestingClosers.has(character)) {
+      depth -= 1;
+    }
+    if (character === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+function extractTupleShapes(idPrefix, tupleText) {
+  if (!tupleText) {
+    return [];
+  }
+  const tupleContents = tupleText.replace(/^\[/u, "").replace(/\]$/u, "").trim();
+  if (!tupleContents) {
+    return [];
+  }
+  return splitTopLevel(tupleContents).map((display, index) => createTypeShape(`${idPrefix}:arg:${index}`, display));
+}
+
+// packages/analyzer/src/workflow-messages.ts
+function readMessageName(call) {
+  const firstArgument = call.getArguments()[0];
+  if (firstArgument && Node2.isStringLiteral(firstArgument)) {
+    return { name: firstArgument.getLiteralValue(), literal: true };
+  }
+  return { name: firstArgument?.getText() || "unknownMessage", literal: false };
+}
+function getMessageKind(initializer) {
+  if (isWorkflowModuleCall(initializer, "defineQuery")) {
+    return "query";
+  }
+  return isWorkflowModuleCall(initializer, "defineUpdate") ? "update" : undefined;
+}
+function createDeclaredMessage(root, sourceFile, variableName, kind, initializer) {
+  const { name, literal } = readMessageName(initializer);
+  const typeArguments = initializer.getTypeArguments();
+  const resultText = typeArguments[0]?.getText();
+  return {
+    variableName,
+    kind,
+    name,
+    source: createSourceLocation(root, sourceFile, initializer, name),
+    args: extractTupleShapes(`${kind}:${name}`, typeArguments[1]?.getText()),
+    ...resultText ? { result: createTypeShape(`${kind}:${name}:result`, resultText) } : {},
+    confidence: literal ? "exact" : "dynamic"
+  };
+}
+function readMessageDeclaration(root, sourceFile, declaration) {
+  const initializer = declaration.getInitializer();
+  const nameNode = declaration.getNameNode();
+  if (!initializer || !Node2.isCallExpression(initializer) || !Node2.isIdentifier(nameNode)) {
+    return;
+  }
+  const kind = getMessageKind(initializer);
+  if (!kind) {
+    return;
+  }
+  return createDeclaredMessage(root, sourceFile, nameNode.getText(), kind, initializer);
+}
+function findMessageDeclarations(root, sourceFile) {
+  const declarations = new Map;
+  for (const declaration of sourceFile.getDescendantsOfKind(SyntaxKind2.VariableDeclaration)) {
+    const declared = readMessageDeclaration(root, sourceFile, declaration);
+    if (declared) {
+      declarations.set(declared.variableName, declared);
+    }
+  }
+  return declarations;
+}
+function readValidatorNode(call) {
+  const options = call.getArguments()[2];
+  if (!options || !Node2.isObjectLiteralExpression(options)) {
+    return;
+  }
+  const property = options.getProperty("validator");
+  if (property && Node2.isPropertyAssignment(property)) {
+    return property.getInitializer();
+  }
+  return property;
+}
+function findMessageRegistrations(functionDeclaration, declaredMessages) {
+  const registrations = [];
+  for (const call of functionDeclaration.getDescendantsOfKind(SyntaxKind2.CallExpression)) {
+    if (!isWorkflowModuleCall(call, "setHandler")) {
+      continue;
+    }
+    const [handleArgument, handlerArgument] = call.getArguments();
+    if (!handleArgument || !Node2.isIdentifier(handleArgument)) {
+      continue;
+    }
+    const declared = declaredMessages.get(handleArgument.getText());
+    if (!declared) {
+      continue;
+    }
+    registrations.push({
+      declared,
+      registration: call,
+      handler: handlerArgument,
+      validator: readValidatorNode(call)
+    });
+  }
+  return registrations;
+}
+function createQueryDefinition(root, workflowName, registration) {
+  const { declared } = registration;
+  return {
+    id: `query:${workflowName}:${declared.name}`,
+    name: declared.name,
+    source: declared.source,
+    args: declared.args,
+    ...declared.result ? { result: declared.result } : {},
+    handlerSource: createSourceLocation(root, registration.registration.getSourceFile(), registration.registration, declared.name),
+    confidence: declared.confidence
+  };
+}
+function createUpdateDefinition(root, workflowName, registration) {
+  const { declared } = registration;
+  const sourceFile = registration.registration.getSourceFile();
+  return {
+    id: `update:${workflowName}:${declared.name}`,
+    name: declared.name,
+    source: declared.source,
+    args: declared.args,
+    ...declared.result ? { result: declared.result } : {},
+    handlerSource: createSourceLocation(root, sourceFile, registration.registration, declared.name),
+    ...registration.validator ? {
+      validatorSource: createSourceLocation(root, sourceFile, registration.validator)
+    } : {},
+    confidence: declared.confidence
+  };
+}
+
+// packages/analyzer/src/workflow-signals.ts
+import {
+  Node as Node3,
+  SyntaxKind as SyntaxKind3
+} from "ts-morph";
+function extractSignalPayloadShapes(signalName, typeArgumentText) {
+  if (!typeArgumentText) {
+    return [];
+  }
+  const tupleContents = typeArgumentText.replace(/^\[/u, "").replace(/\]$/u, "").trim();
+  if (!tupleContents) {
+    return [];
+  }
+  return splitTopLevel2(tupleContents).map((display, index) => createTypeShape(`signal:${signalName}:arg:${index}`, display));
+}
+var nestingOpeners2 = new Set(["<", "[", "{", "("]);
+var nestingClosers2 = new Set([">", "]", "}", ")"]);
+function splitTopLevel2(contents) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const character of contents) {
+    if (nestingOpeners2.has(character)) {
+      depth += 1;
+    } else if (nestingClosers2.has(character)) {
+      depth -= 1;
+    }
+    if (character === "," && depth === 0) {
+      parts.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += character;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+function getDefineSignalCall(declaration) {
+  const initializer = declaration.getInitializer();
+  if (!initializer || !Node3.isCallExpression(initializer)) {
+    return;
+  }
+  return isWorkflowModuleCall(initializer, "defineSignal") ? initializer : undefined;
+}
+function readSignalName(call) {
+  const firstArgument = call.getArguments()[0];
+  if (firstArgument && Node3.isStringLiteral(firstArgument)) {
+    return { name: firstArgument.getLiteralValue(), literal: true };
+  }
+  return { name: firstArgument?.getText() || "unknownSignal", literal: false };
+}
+function readSignalDeclaration(root, sourceFile, declaration) {
+  const call = getDefineSignalCall(declaration);
+  const nameNode = declaration.getNameNode();
+  if (!call || !Node3.isIdentifier(nameNode)) {
+    return;
+  }
+  const { name, literal } = readSignalName(call);
+  return {
+    variableName: nameNode.getText(),
+    name,
+    source: createSourceLocation(root, sourceFile, call, name),
+    args: extractSignalPayloadShapes(name, call.getTypeArguments()[0]?.getText()),
+    confidence: literal ? "exact" : "dynamic"
+  };
+}
+function findSignalDeclarations(root, sourceFile) {
+  const declarations = new Map;
+  for (const declaration of sourceFile.getDescendantsOfKind(SyntaxKind3.VariableDeclaration)) {
+    const declared = readSignalDeclaration(root, sourceFile, declaration);
+    if (declared) {
+      declarations.set(declared.variableName, declared);
+    }
+  }
+  return declarations;
+}
+function findSignalRegistrations(root, workflowName, functionDeclaration, declaredSignals) {
+  const registrations = [];
+  const sourceFile = functionDeclaration.getSourceFile();
+  for (const call of functionDeclaration.getDescendantsOfKind(SyntaxKind3.CallExpression)) {
+    if (!isWorkflowModuleCall(call, "setHandler")) {
+      continue;
+    }
+    const [handleArgument] = call.getArguments();
+    if (!handleArgument || !Node3.isIdentifier(handleArgument)) {
+      continue;
+    }
+    const declared = declaredSignals.get(handleArgument.getText());
+    if (!declared) {
+      continue;
+    }
+    registrations.push({
+      id: `signal:${workflowName}:${declared.name}`,
+      name: declared.name,
+      source: declared.source,
+      args: declared.args,
+      handlerSource: createSourceLocation(root, sourceFile, call, declared.name),
+      confidence: declared.confidence
+    });
+  }
+  return registrations.toSorted((left, right) => left.name.localeCompare(right.name));
+}
+
+// packages/analyzer/src/determinism-diagnostics.ts
+var unsafeBareModules = new Set([
+  "fs",
+  "path",
+  "os",
+  "http",
+  "https",
+  "net",
+  "dns",
+  "crypto",
+  "child_process",
+  "worker_threads",
+  "cluster"
+]);
+var nondeterministicCalls = new Map([
+  ["Date.now", "Date.now()"],
+  ["Math.random", "Math.random()"]
+]);
+function createDeterminismDiagnostic(root, code, message, node, severity = "error") {
+  return {
+    code,
+    category: "determinism",
+    severity,
+    message,
+    source: createSourceLocation(root, node.getSourceFile(), node),
+    confidence: "exact"
+  };
+}
+function findUnsafeImportDiagnostics(root, sourceFile) {
+  const diagnostics = [];
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    const specifier = importDeclaration.getModuleSpecifierValue();
+    if (specifier.startsWith("node:") || unsafeBareModules.has(specifier)) {
+      diagnostics.push(createDeterminismDiagnostic(root, "TEA_UNSAFE_WORKFLOW_IMPORT", `Workflow file imports ${specifier}, which is not available in the deterministic Workflow sandbox.`, importDeclaration));
+    }
+  }
+  return diagnostics;
+}
+function findNondeterministicApiDiagnostics(root, functionDeclaration) {
+  const diagnostics = [];
+  for (const call of functionDeclaration.getDescendantsOfKind(SyntaxKind4.CallExpression)) {
+    const expressionText = call.getExpression().getText();
+    const label = nondeterministicCalls.get(expressionText);
+    if (label) {
+      diagnostics.push(createDeterminismDiagnostic(root, "TEA_NONDETERMINISTIC_API", `Potential nondeterministic API inside Workflow: ${label}`, call));
+    }
+  }
+  for (const newExpression of functionDeclaration.getDescendantsOfKind(SyntaxKind4.NewExpression)) {
+    if (newExpression.getExpression().getText() === "Date" && newExpression.getArguments().length === 0) {
+      diagnostics.push(createDeterminismDiagnostic(root, "TEA_NONDETERMINISTIC_API", "Potential nondeterministic API inside Workflow: new Date()", newExpression));
+    }
+  }
+  return diagnostics;
+}
+function findDuplicateMessageDiagnostics(root, sourceFile) {
+  const diagnostics = [];
+  const byName = new Map;
+  const declarations = [
+    ...[...findSignalDeclarations(root, sourceFile).values()].map((declared) => ({
+      name: declared.name,
+      kind: "Signal",
+      source: declared.source
+    })),
+    ...[...findMessageDeclarations(root, sourceFile).values()].map((declared) => ({
+      name: declared.name,
+      kind: declared.kind === "query" ? "Query" : "Update",
+      source: declared.source
+    }))
+  ];
+  for (const declared of declarations) {
+    byName.set(declared.name, (byName.get(declared.name) ?? 0) + 1);
+  }
+  for (const declared of declarations) {
+    if ((byName.get(declared.name) ?? 0) > 1) {
+      diagnostics.push({
+        code: "TEA_DUPLICATE_MESSAGE_NAME",
+        category: "discovery",
+        severity: "error",
+        message: `${declared.kind} name "${declared.name}" is defined more than once in this file.`,
+        source: declared.source,
+        confidence: "exact"
+      });
+    }
+  }
+  return diagnostics;
+}
+
+// packages/analyzer/src/handler-diagnostics.ts
+import { Node as Node5, SyntaxKind as SyntaxKind5 } from "ts-morph";
+var commandApiNames = [
+  "sleep",
+  "condition",
+  "startChild",
+  "executeChild",
+  "continueAsNew",
+  "getExternalWorkflowHandle"
+];
+var assignmentOperators = new Set([
+  SyntaxKind5.EqualsToken,
+  SyntaxKind5.PlusEqualsToken,
+  SyntaxKind5.MinusEqualsToken,
+  SyntaxKind5.AsteriskEqualsToken,
+  SyntaxKind5.SlashEqualsToken,
+  SyntaxKind5.PercentEqualsToken,
+  SyntaxKind5.AmpersandAmpersandEqualsToken,
+  SyntaxKind5.BarBarEqualsToken,
+  SyntaxKind5.QuestionQuestionEqualsToken
+]);
+function isFunctionLike(node) {
+  return Node5.isArrowFunction(node) || Node5.isFunctionExpression(node) || Node5.isFunctionDeclaration(node);
+}
+function isDeclaredInside(identifier, container) {
+  const symbol = identifier.getSymbol();
+  return symbol?.getDeclarations().some((declaration) => declaration.getSourceFile() === container.getSourceFile() && declaration.getStart() >= container.getStart() && declaration.getEnd() <= container.getEnd()) ?? false;
+}
+function createDiagnostic(root, code, message, node) {
+  return {
+    code,
+    category: "determinism",
+    severity: "error",
+    message,
+    source: createSourceLocation(root, node.getSourceFile(), node),
+    confidence: "exact"
+  };
+}
+function getAssignmentTarget(target) {
+  if (Node5.isIdentifier(target)) {
+    return target;
+  }
+  return Node5.isPropertyAccessExpression(target) ? target.getExpression() : undefined;
+}
+function isOuterStateMutation(target, handler) {
+  return Boolean(target && Node5.isIdentifier(target) && !isDeclaredInside(target, handler));
+}
+function createMutationDiagnostic(root, queryName, expression) {
+  return createDiagnostic(root, "TEA_QUERY_STATE_MUTATION", `Query handler ${queryName} mutates Workflow state: ${expression.getText()}`, expression);
+}
+function findAssignmentMutations(root, queryName, handler, diagnostics) {
+  for (const binary of handler.getDescendantsOfKind(SyntaxKind5.BinaryExpression)) {
+    if (!assignmentOperators.has(binary.getOperatorToken().getKind())) {
+      continue;
+    }
+    if (isOuterStateMutation(getAssignmentTarget(binary.getLeft()), handler)) {
+      diagnostics.push(createMutationDiagnostic(root, queryName, binary));
+    }
+  }
+}
+function findIncrementMutations(root, queryName, handler, diagnostics) {
+  const unaryExpressions = [
+    ...handler.getDescendantsOfKind(SyntaxKind5.PostfixUnaryExpression),
+    ...handler.getDescendantsOfKind(SyntaxKind5.PrefixUnaryExpression)
+  ];
+  for (const unary of unaryExpressions) {
+    const operator = unary.getOperatorToken();
+    if (operator !== SyntaxKind5.PlusPlusToken && operator !== SyntaxKind5.MinusMinusToken) {
+      continue;
+    }
+    if (isOuterStateMutation(unary.getOperand(), handler)) {
+      diagnostics.push(createMutationDiagnostic(root, queryName, unary));
+    }
+  }
+}
+function findMutationDiagnostics(root, queryName, handler, diagnostics) {
+  findAssignmentMutations(root, queryName, handler, diagnostics);
+  findIncrementMutations(root, queryName, handler, diagnostics);
+}
+function findCommandDiagnostics(root, queryName, handler, proxyVariables, diagnostics) {
+  for (const call of handler.getDescendantsOfKind(SyntaxKind5.CallExpression)) {
+    const expression = call.getExpression();
+    if (Node5.isPropertyAccessExpression(expression)) {
+      const receiver = expression.getExpression();
+      if (Node5.isIdentifier(receiver) && proxyVariables.has(receiver.getText())) {
+        diagnostics.push(createDiagnostic(root, "TEA_QUERY_COMMAND_IN_HANDLER", `Query handler ${queryName} calls Activity ${expression.getName()}.`, call));
+      }
+      continue;
+    }
+    for (const apiName of commandApiNames) {
+      if (isWorkflowModuleCall(call, apiName)) {
+        diagnostics.push(createDiagnostic(root, "TEA_QUERY_COMMAND_IN_HANDLER", `Query handler ${queryName} uses ${apiName}, which is not allowed in Queries.`, call));
+      }
+    }
+  }
+}
+function analyzeQueryHandler(root, queryName, handler, proxyVariables) {
+  if (!handler || !isFunctionLike(handler)) {
+    return [];
+  }
+  const diagnostics = [];
+  if ((Node5.isArrowFunction(handler) || Node5.isFunctionExpression(handler)) && handler.isAsync()) {
+    diagnostics.push(createDiagnostic(root, "TEA_QUERY_ASYNC_HANDLER", `Query handler ${queryName} may not be async.`, handler));
+  }
+  findMutationDiagnostics(root, queryName, handler, diagnostics);
+  findCommandDiagnostics(root, queryName, handler, proxyVariables, diagnostics);
+  return diagnostics;
+}
+function analyzeUpdateValidator(root, updateName, validator) {
+  if (!validator) {
+    return [];
+  }
+  if ((Node5.isArrowFunction(validator) || Node5.isFunctionExpression(validator)) && validator.isAsync()) {
+    return [
+      createDiagnostic(root, "TEA_UPDATE_ASYNC_VALIDATOR", `Update validator for ${updateName} may not be async.`, validator)
+    ];
+  }
+  return [];
+}
+
+// packages/analyzer/src/type-imports.ts
+function toModulePath(root, filePath) {
+  return toProjectPath(root, filePath).replace(/\.tsx?$/u, "");
+}
+function collectNamedTypeSources(root, sourceFile) {
+  const sources = [];
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+    if (!moduleSourceFile || moduleSourceFile.isInNodeModules()) {
+      continue;
+    }
+    const module = toModulePath(root, moduleSourceFile.getFilePath());
+    for (const namedImport of importDeclaration.getNamedImports()) {
+      sources.push({ name: namedImport.getName(), module });
+    }
+  }
+  const ownModule = toModulePath(root, sourceFile.getFilePath());
+  for (const typeAlias of sourceFile.getTypeAliases()) {
+    if (typeAlias.isExported()) {
+      sources.push({ name: typeAlias.getName(), module: ownModule });
+    }
+  }
+  for (const interfaceDeclaration of sourceFile.getInterfaces()) {
+    if (interfaceDeclaration.isExported()) {
+      sources.push({ name: interfaceDeclaration.getName(), module: ownModule });
+    }
+  }
+  return sources;
+}
+function collectDisplayTexts(workflow, signals, queries, updates) {
+  const texts = [
+    ...workflow.signature.args.map((arg) => arg.display),
+    workflow.signature.result.display
+  ];
+  for (const message of [...signals, ...queries, ...updates]) {
+    texts.push(...message.args.map((arg) => arg.display));
+  }
+  for (const message of [...queries, ...updates]) {
+    if (message.result) {
+      texts.push(message.result.display);
+    }
+  }
+  return texts;
+}
+function collectTypeImportDependencies(root, sourceFile, workflow, signals, queries, updates) {
+  const displayTexts = collectDisplayTexts(workflow, signals, queries, updates);
+  const dependencies = new Map;
+  for (const candidate of collectNamedTypeSources(root, sourceFile)) {
+    const pattern = new RegExp(`\\b${candidate.name}\\b`, "u");
+    if (displayTexts.some((text) => pattern.test(text))) {
+      dependencies.set(candidate.name, {
+        kind: "type-import",
+        name: candidate.name,
+        module: candidate.module
+      });
+    }
+  }
+  return [...dependencies.values()].toSorted((left, right) => left.name.localeCompare(right.name));
+}
+
+// packages/analyzer/src/workflow-commands.ts
+import {
+  Node as Node7,
+  SyntaxKind as SyntaxKind6
+} from "ts-morph";
+
+// packages/analyzer/src/command-factories.ts
+import { Node as Node6 } from "ts-morph";
+function commandSource(root, call, symbolName) {
+  return createSourceLocation(root, call.getSourceFile(), call, symbolName);
+}
+function createActivityCommand(root, workflowName, activityName, call, order) {
+  return {
+    id: `activity-call:${workflowName}:${activityName}:${order}`,
+    kind: "activity",
+    name: activityName,
+    source: commandSource(root, call, activityName),
+    confidence: "exact",
+    staticOrder: order
+  };
+}
+function createConditionCommands(root, workflowName, call, startOrder) {
+  const [predicate, timeout] = call.getArguments();
+  const commands = [
+    {
+      id: `condition:${workflowName}:${startOrder}`,
+      kind: "condition",
+      name: predicate?.getText() ?? "condition",
+      source: commandSource(root, call),
+      confidence: "exact",
+      staticOrder: startOrder
+    }
+  ];
+  if (timeout) {
+    commands.push({
+      id: `timer:${workflowName}:${startOrder + 1}`,
+      kind: "timer",
+      name: timeout.getText(),
+      source: commandSource(root, call),
+      confidence: "exact",
+      staticOrder: startOrder + 1
+    });
+  }
+  return commands;
+}
+function createSleepCommand(root, workflowName, call, order) {
+  return {
+    id: `timer:${workflowName}:${order}`,
+    kind: "timer",
+    name: call.getArguments()[0]?.getText() ?? "sleep",
+    source: commandSource(root, call),
+    confidence: "exact",
+    staticOrder: order
+  };
+}
+function resolveChildWorkflowTarget(target) {
+  if (target && Node6.isStringLiteral(target)) {
+    return { name: target.getLiteralValue(), confidence: "exact" };
+  }
+  if (target && Node6.isIdentifier(target)) {
+    return { name: target.getText(), confidence: "exact" };
+  }
+  return { name: target?.getText() || "unknownChildWorkflow", confidence: "dynamic" };
+}
+function createChildWorkflowCommand(root, workflowName, call, order) {
+  const { name, confidence } = resolveChildWorkflowTarget(call.getArguments()[0]);
+  return {
+    id: `child-workflow:${workflowName}:${name}:${order}`,
+    kind: "child-workflow",
+    name,
+    source: commandSource(root, call, name),
+    confidence,
+    staticOrder: order
+  };
+}
+function createExternalSignalCommand(root, workflowName, signalName, confidence, call, order) {
+  return {
+    id: `external-workflow:${workflowName}:${signalName}:${order}`,
+    kind: "external-workflow",
+    name: signalName,
+    source: commandSource(root, call, signalName),
+    confidence,
+    staticOrder: order
+  };
+}
+function createContinueAsNewCommand(root, workflowName, call, order) {
+  const typeArgument = call.getTypeArguments()[0]?.getText();
+  const target = typeArgument?.startsWith("typeof ") ? typeArgument.slice("typeof ".length) : typeArgument;
+  return {
+    id: `continue-as-new:${workflowName}:${order}`,
+    kind: "continue-as-new",
+    name: target ?? "continueAsNew",
+    source: commandSource(root, call),
+    confidence: "exact",
+    staticOrder: order
+  };
+}
+function createPatchCommand(root, workflowName, call, order) {
+  const [patchArgument] = call.getArguments();
+  const literalId = patchArgument && Node6.isStringLiteral(patchArgument) ? patchArgument.getLiteralValue() : undefined;
+  return {
+    id: `patch:${workflowName}:${order}`,
+    kind: "patch",
+    name: literalId ?? (patchArgument?.getText() || "unknownPatch"),
+    source: commandSource(root, call),
+    confidence: literalId ? "exact" : "dynamic",
+    staticOrder: order
+  };
+}
+function createCancellationScopeCommand(root, workflowName, scopeKind, call, order) {
+  return {
+    id: `cancellation-scope:${workflowName}:${order}`,
+    kind: "cancellation-scope",
+    name: scopeKind,
+    source: commandSource(root, call),
+    confidence: "exact",
+    staticOrder: order
+  };
+}
+function createDynamicCommand(root, workflowName, expressionText, call, order) {
+  return {
+    id: `dynamic:${workflowName}:${order}`,
+    kind: "dynamic",
+    name: expressionText,
+    source: commandSource(root, call),
+    confidence: "dynamic",
+    staticOrder: order
+  };
+}
+
+// packages/analyzer/src/workflow-commands.ts
+function getProxyPropertyAccessExpression(call, proxyVariables) {
+  const expression = call.getExpression();
+  if (!Node7.isPropertyAccessExpression(expression)) {
+    return;
+  }
+  const receiver = expression.getExpression();
+  return Node7.isIdentifier(receiver) && proxyVariables.has(receiver.getText()) ? expression : undefined;
+}
+function getDynamicProxyAccess(call, proxyVariables) {
+  const expression = call.getExpression();
+  if (!Node7.isElementAccessExpression(expression)) {
+    return;
+  }
+  const receiver = expression.getExpression();
+  return Node7.isIdentifier(receiver) && proxyVariables.has(receiver.getText()) ? expression : undefined;
+}
+function createDynamicActivityDiagnostic(root, call, expression) {
+  return {
+    code: "TEA_DYNAMIC_ACTIVITY_CALL",
+    category: "control-flow",
+    severity: "warning",
+    message: `Dynamic Activity call could not be fully resolved: ${expression.getText()}`,
+    source: createSourceLocation(root, call.getSourceFile(), call),
+    confidence: "dynamic"
+  };
+}
+function findExternalHandleVariables(functionDeclaration) {
+  const handles = new Set;
+  for (const declaration of functionDeclaration.getDescendantsOfKind(SyntaxKind6.VariableDeclaration)) {
+    const initializer = declaration.getInitializer();
+    const nameNode = declaration.getNameNode();
+    if (initializer && Node7.isCallExpression(initializer) && isWorkflowModuleCall(initializer, "getExternalWorkflowHandle") && Node7.isIdentifier(nameNode)) {
+      handles.add(nameNode.getText());
+    }
+  }
+  return handles;
+}
+function getCancellationScopeKind(call) {
+  const expression = call.getExpression();
+  if (!Node7.isPropertyAccessExpression(expression)) {
+    return;
+  }
+  const receiver = expression.getExpression();
+  if (!Node7.isIdentifier(receiver) || !isNamedImportFrom(receiver, temporalWorkflowModule, "CancellationScope")) {
+    return;
+  }
+  return expression.getName();
+}
+function isExternalHandleSignalCall(call, externalHandles) {
+  const expression = call.getExpression();
+  if (!Node7.isPropertyAccessExpression(expression) || expression.getName() !== "signal") {
+    return false;
+  }
+  const receiver = expression.getExpression();
+  return Node7.isIdentifier(receiver) && externalHandles.has(receiver.getText());
+}
+function resolveSignalArgumentName(signalArgument, signalNamesByVariable) {
+  if (signalArgument && Node7.isStringLiteral(signalArgument)) {
+    return { name: signalArgument.getLiteralValue(), confidence: "exact" };
+  }
+  if (signalArgument && Node7.isIdentifier(signalArgument)) {
+    const declared = signalNamesByVariable.get(signalArgument.getText());
+    if (declared) {
+      return { name: declared, confidence: "exact" };
+    }
+  }
+  return { name: signalArgument?.getText() || "unknownSignal", confidence: "dynamic" };
+}
+function getExternalSignalName(call, externalHandles, signalNamesByVariable) {
+  if (!isExternalHandleSignalCall(call, externalHandles)) {
+    return;
+  }
+  return resolveSignalArgumentName(call.getArguments()[0], signalNamesByVariable);
+}
+function getDestructuredActivityName(call, destructuredActivities) {
+  const expression = call.getExpression();
+  return Node7.isIdentifier(expression) ? destructuredActivities.get(expression.getText()) : undefined;
+}
+function collectCall(call, context) {
+  const { root, workflowName, commands } = context;
+  const proxyAccess = getProxyPropertyAccessExpression(call, context.proxyVariables);
+  if (proxyAccess) {
+    commands.push(createActivityCommand(root, workflowName, proxyAccess.getName(), call, commands.length));
+    return;
+  }
+  const destructuredActivity = getDestructuredActivityName(call, context.destructuredActivities);
+  if (destructuredActivity) {
+    commands.push(createActivityCommand(root, workflowName, destructuredActivity, call, commands.length));
+    return;
+  }
+  const dynamicAccess = getDynamicProxyAccess(call, context.proxyVariables);
+  if (dynamicAccess) {
+    commands.push(createDynamicCommand(root, workflowName, dynamicAccess.getText(), call, commands.length));
+    context.diagnostics.push(createDynamicActivityDiagnostic(root, call, dynamicAccess));
+    return;
+  }
+  const scopeKind = getCancellationScopeKind(call);
+  if (scopeKind) {
+    commands.push(createCancellationScopeCommand(root, workflowName, scopeKind, call, commands.length));
+    return;
+  }
+  const externalSignal = getExternalSignalName(call, context.externalHandles, context.signalNamesByVariable);
+  if (externalSignal) {
+    commands.push(createExternalSignalCommand(root, workflowName, externalSignal.name, externalSignal.confidence, call, commands.length));
+    return;
+  }
+  collectWorkflowModuleCall(call, context);
+}
+function collectWorkflowModuleCall(call, context) {
+  const { root, workflowName, commands } = context;
+  if (isWorkflowModuleCall(call, "condition")) {
+    commands.push(...createConditionCommands(root, workflowName, call, commands.length));
+  } else if (isWorkflowModuleCall(call, "sleep")) {
+    commands.push(createSleepCommand(root, workflowName, call, commands.length));
+  } else if (isWorkflowModuleCall(call, "startChild") || isWorkflowModuleCall(call, "executeChild")) {
+    commands.push(createChildWorkflowCommand(root, workflowName, call, commands.length));
+  } else if (isWorkflowModuleCall(call, "continueAsNew")) {
+    commands.push(createContinueAsNewCommand(root, workflowName, call, commands.length));
+  } else if (isWorkflowModuleCall(call, "patched") || isWorkflowModuleCall(call, "deprecatePatch")) {
+    commands.push(createPatchCommand(root, workflowName, call, commands.length));
+  }
+}
+function collectTemporalCommands(root, workflowName, functionDeclaration, proxyVariables) {
+  const signalNamesByVariable = new Map;
+  for (const [variableName, declared] of findSignalDeclarations(root, functionDeclaration.getSourceFile())) {
+    signalNamesByVariable.set(variableName, declared.name);
+  }
+  const context = {
+    root,
+    workflowName,
+    proxyVariables,
+    destructuredActivities: findDestructuredActivityBindings(functionDeclaration.getSourceFile(), proxyVariables),
+    externalHandles: findExternalHandleVariables(functionDeclaration),
+    signalNamesByVariable,
+    commands: [],
+    diagnostics: []
+  };
+  for (const call of functionDeclaration.getDescendantsOfKind(SyntaxKind6.CallExpression)) {
+    collectCall(call, context);
+  }
+  return { commands: context.commands, diagnostics: context.diagnostics };
+}
+
+// packages/analyzer/src/workflow-analysis.ts
+function findNamespaceImportSource(sourceFile) {
+  for (const importDeclaration of sourceFile.getImportDeclarations()) {
+    if (!importDeclaration.getNamespaceImport()) {
+      continue;
+    }
+    const moduleSourceFile = importDeclaration.getModuleSpecifierSourceFile();
+    if (moduleSourceFile)
+      return moduleSourceFile;
+  }
+  return;
+}
+function findActivityImplementationSource(activitySourceFile, activityName, root) {
+  const declaration = activitySourceFile?.getFunction(activityName);
+  if (!declaration || !activitySourceFile) {
+    return;
+  }
+  return createSourceLocation(root, activitySourceFile, declaration, activityName);
+}
+function getFunctionReturnDisplay(functionDeclaration) {
+  return functionDeclaration.getReturnTypeNode()?.getText() ?? functionDeclaration.getReturnType().getText(functionDeclaration);
+}
+function createWorkflowSignature(root, functionDeclaration) {
+  const sourceFile = functionDeclaration.getSourceFile();
+  const args = functionDeclaration.getParameters().map((parameter, index) => {
+    const name = parameter.getName();
+    const display = parameter.getTypeNode()?.getText() ?? parameter.getType().getText(parameter);
+    return createTypeShape(`${functionDeclaration.getName() ?? "anonymous"}:arg:${index}:${name}`, display, createSourceLocation(root, sourceFile, parameter, name), name);
+  });
+  return {
+    args,
+    result: createTypeShape(`${functionDeclaration.getName() ?? "anonymous"}:result`, getFunctionReturnDisplay(functionDeclaration))
+  };
+}
+function analyzeMessageHandlers(root, registrations, proxyVariables) {
+  return registrations.flatMap((registration) => registration.declared.kind === "query" ? analyzeQueryHandler(root, registration.declared.name, registration.handler, proxyVariables) : analyzeUpdateValidator(root, registration.declared.name, registration.validator));
+}
+function analyzeWorkflowFunction(root, functionDeclaration, proxyVariables) {
+  const workflowName = functionDeclaration.getName() ?? "anonymousWorkflow";
+  const collected = collectTemporalCommands(root, workflowName, functionDeclaration, proxyVariables);
+  const signals = findSignalRegistrations(root, workflowName, functionDeclaration, findSignalDeclarations(root, functionDeclaration.getSourceFile()));
+  const registrations = findMessageRegistrations(functionDeclaration, findMessageDeclarations(root, functionDeclaration.getSourceFile()));
+  const queries = registrations.filter((registration) => registration.declared.kind === "query").map((registration) => createQueryDefinition(root, workflowName, registration)).toSorted((left, right) => left.name.localeCompare(right.name));
+  const updates = registrations.filter((registration) => registration.declared.kind === "update").map((registration) => createUpdateDefinition(root, workflowName, registration)).toSorted((left, right) => left.name.localeCompare(right.name));
+  const diagnostics = [
+    ...collected.diagnostics,
+    ...analyzeMessageHandlers(root, registrations, proxyVariables),
+    ...findNondeterministicApiDiagnostics(root, functionDeclaration)
+  ];
+  const signature = createWorkflowSignature(root, functionDeclaration);
+  return {
+    id: `workflow:${workflowName}`,
+    name: workflowName,
+    source: createSourceLocation(root, functionDeclaration.getSourceFile(), functionDeclaration, workflowName),
+    exported: functionDeclaration.isExported(),
+    signature,
+    messageSurface: {
+      signals,
+      queries,
+      updates
+    },
+    state: {
+      variables: []
+    },
+    body: {
+      nodes: []
+    },
+    temporalCommands: collected.commands,
+    dependencies: collectTypeImportDependencies(root, functionDeclaration.getSourceFile(), { signature }, signals, queries, updates),
+    diagnostics
+  };
+}
+function analyzeActivities(root, workflow, activitySourceFile, diagnostics) {
+  return workflow.temporalCommands.filter((command) => command.kind === "activity").map((command) => {
+    const implementationSource = findActivityImplementationSource(activitySourceFile, command.name, root);
+    if (!implementationSource) {
+      diagnostics.push({
+        code: "TEA_UNRESOLVED_ACTIVITY_IMPLEMENTATION",
+        category: "discovery",
+        severity: "warning",
+        message: `Activity implementation for ${command.name} could not be resolved statically.`,
+        source: command.source,
+        confidence: "inferred"
+      });
+    }
+    return {
+      id: `activity:${command.name}`,
+      name: command.name,
+      source: command.source,
+      ...implementationSource ? { implementationSource } : {},
+      confidence: implementationSource ? "exact" : "inferred"
+    };
+  });
+}
+function analyzeWorkerFiles(project, root) {
+  const workers = [];
+  for (const sourceFile of project.getSourceFiles()) {
+    if (!sourceFile.getFilePath().includes("/worker")) {
+      continue;
+    }
+    for (const call of sourceFile.getDescendantsOfKind(SyntaxKind7.CallExpression)) {
+      const expression = call.getExpression();
+      const receiver = Node8.isPropertyAccessExpression(expression) ? expression.getExpression() : undefined;
+      if (!Node8.isPropertyAccessExpression(expression) || expression.getName() !== "create" || !Node8.isIdentifier(receiver) || !isNamedImportFrom(receiver, temporalWorkerModule, "Worker")) {
+        continue;
+      }
+      workers.push({
+        id: `worker:${workers.length}`,
+        source: createSourceLocation(root, sourceFile, call, "Worker.create"),
+        confidence: "inferred"
+      });
+    }
+  }
+  return workers;
+}
+function analyzeWorkflowSourceFile(root, sourceFile) {
+  const workflows = [];
+  const activities = [];
+  const diagnostics = [
+    ...findUnsafeImportDiagnostics(root, sourceFile),
+    ...findDuplicateMessageDiagnostics(root, sourceFile)
+  ];
+  const proxyVariables = findActivityProxyVariables(sourceFile);
+  const activitySourceFile = findNamespaceImportSource(sourceFile);
+  for (const functionDeclaration of sourceFile.getFunctions()) {
+    if (!functionDeclaration.isExported()) {
+      continue;
+    }
+    const workflow = analyzeWorkflowFunction(root, functionDeclaration, proxyVariables);
+    workflows.push(workflow);
+    activities.push(...analyzeActivities(root, workflow, activitySourceFile, diagnostics));
+    diagnostics.push(...workflow.diagnostics);
+  }
+  return { workflows, activities, diagnostics };
+}
+
+// packages/analyzer/src/index.ts
+var workflowGlobs = ["src/**/workflows/**/*.ts", "src/**/*.workflow.ts", "src/**/workflows.ts"];
+var workerGlobs = ["src/**/worker*.ts", "src/**/workers/**/*.ts"];
+async function resolveWorkflowFiles(root, options, configuration) {
+  if (options.workflowFiles) {
+    return options.workflowFiles.map((file) => resolve3(root, file));
+  }
+  return await discoverFiles(root, configuration?.temporal?.workflowGlobs ?? workflowGlobs);
+}
+function resolveProjectPaths(options, configuration) {
+  return {
+    tsconfigName: options.tsconfig ?? configuration?.tsconfig ?? "tsconfig.json",
+    outputName: options.outputDirectory ?? configuration?.output?.directory ?? ".temporal-explorer"
+  };
+}
+async function loadTemporalExplorerProject(options = {}) {
+  const root = resolve3(options.root ?? process.cwd());
+  const configuration = await loadConfiguration(resolve3(root, "temporal-explorer.config.ts"));
+  const { tsconfigName, outputName } = resolveProjectPaths(options, configuration);
+  return {
+    root,
+    tsconfig: resolve3(root, tsconfigName),
+    workflowFiles: await resolveWorkflowFiles(root, options, configuration),
+    outputDirectory: resolve3(root, outputName),
+    ...configuration ? { configuration } : {}
+  };
+}
+async function createProjectWithSources(root, tsconfig, workflowFiles) {
+  const project = new Project({ tsConfigFilePath: tsconfig });
+  for (const workflowFile of workflowFiles) {
+    project.addSourceFileAtPathIfExists(workflowFile);
+  }
+  for (const workerFile of await discoverFiles(root, workerGlobs)) {
+    project.addSourceFileAtPathIfExists(workerFile);
+  }
+  return project;
+}
+function resolveDeclaringSourceFiles(sourceFile) {
+  const files = new Map([[sourceFile.getFilePath(), sourceFile]]);
+  for (const exportDeclaration of sourceFile.getExportDeclarations()) {
+    const target = exportDeclaration.getModuleSpecifierSourceFile();
+    if (target) {
+      files.set(target.getFilePath(), target);
+    }
+  }
+  return [...files.values()];
+}
+function collectWorkflowAnalysis(project, root, workflowFiles) {
+  const workflows = [];
+  const activities = [];
+  const diagnostics = [];
+  const analyzedPaths = new Set;
+  for (const workflowFile of workflowFiles) {
+    for (const sourceFile of resolveDeclaringSourceFiles(project.getSourceFileOrThrow(workflowFile))) {
+      if (analyzedPaths.has(sourceFile.getFilePath())) {
+        continue;
+      }
+      analyzedPaths.add(sourceFile.getFilePath());
+      const analysis = analyzeWorkflowSourceFile(root, sourceFile);
+      workflows.push(...analysis.workflows);
+      activities.push(...analysis.activities);
+      diagnostics.push(...analysis.diagnostics);
+    }
+  }
+  return { workflows, activities, diagnostics };
+}
+async function analyzeWorkflowFiles(options) {
+  const root = resolve3(options.projectRoot);
+  const workflowFiles = options.workflowFiles.map((file) => resolve3(root, file));
+  const tsconfig = resolve3(root, options.tsconfig);
+  const project = await createProjectWithSources(root, tsconfig, workflowFiles);
+  const collected = collectWorkflowAnalysis(project, root, workflowFiles);
+  const packageJson = await readPackageJson(root);
+  const sourceFileHashes = await createSourceFileHashes(root, workflowFiles);
+  const configHash = await hashFile(tsconfig);
+  const temporalTypeScriptVersion = packageJson.dependencies?.["@temporalio/workflow"];
+  const packageManager = getPackageManager(packageJson);
+  const projectName = basename(root);
+  return {
+    schemaVersion: "temporal-analysis/v1",
+    artifactId: `analysis:${projectName}`,
+    metadata: {
+      temporalExplorerVersion: "0.0.0-mvp",
+      schemaVersion: "temporal-analysis/v1",
+      inputs: {
+        projectRoot: projectName,
+        configHash,
+        tsconfigHash: configHash,
+        sourceFileHashes,
+        temporalSdkVersions: temporalTypeScriptVersion ? {
+          "@temporalio/workflow": temporalTypeScriptVersion
+        } : {}
+      }
+    },
+    project: {
+      root: projectName,
+      tsconfig: toProjectPath(root, tsconfig),
+      ...packageManager ? { packageManager } : {}
+    },
+    sdk: {
+      ...temporalTypeScriptVersion ? { temporalTypeScriptVersion } : {},
+      detectedPackages: temporalTypeScriptVersion ? ["@temporalio/workflow"] : []
+    },
+    workers: analyzeWorkerFiles(project, root),
+    workflows: collected.workflows,
+    activities: collected.activities,
+    clients: [],
+    diagnostics: collected.diagnostics
+  };
+}
+async function analyzeProject(project) {
+  return await analyzeWorkflowFiles({
+    projectRoot: project.root,
+    tsconfig: project.tsconfig,
+    workflowFiles: project.workflowFiles,
+    outputDirectory: project.outputDirectory
+  });
+}
+
+// packages/history/src/index.ts
+import { createHash } from "crypto";
+import { basename as basename2, dirname, join, relative as relative2, resolve as resolve4 } from "path";
+
+// packages/history/src/event-types.ts
+var eventTypes = {
+  workflowExecutionStarted: 1,
+  workflowExecutionCompleted: 2,
+  workflowExecutionFailed: 3,
+  workflowExecutionTimedOut: 4,
+  workflowTaskScheduled: 5,
+  workflowTaskStarted: 6,
+  workflowTaskCompleted: 7,
+  workflowTaskTimedOut: 8,
+  workflowTaskFailed: 9,
+  activityTaskScheduled: 10,
+  activityTaskStarted: 11,
+  activityTaskCompleted: 12,
+  activityTaskFailed: 13,
+  activityTaskTimedOut: 14,
+  activityTaskCancelRequested: 15,
+  activityTaskCanceled: 16,
+  timerStarted: 17,
+  timerFired: 18,
+  timerCanceled: 19,
+  workflowExecutionCancelRequested: 20,
+  workflowExecutionCanceled: 21,
+  requestCancelExternalWorkflowExecutionInitiated: 22,
+  requestCancelExternalWorkflowExecutionFailed: 23,
+  externalWorkflowExecutionCancelRequested: 24,
+  markerRecorded: 25,
+  workflowExecutionSignaled: 26,
+  workflowExecutionTerminated: 27,
+  workflowExecutionContinuedAsNew: 28,
+  startChildWorkflowExecutionInitiated: 29,
+  startChildWorkflowExecutionFailed: 30,
+  childWorkflowExecutionStarted: 31,
+  childWorkflowExecutionCompleted: 32,
+  childWorkflowExecutionFailed: 33,
+  childWorkflowExecutionCanceled: 34,
+  childWorkflowExecutionTimedOut: 35,
+  childWorkflowExecutionTerminated: 36,
+  signalExternalWorkflowExecutionInitiated: 37,
+  signalExternalWorkflowExecutionFailed: 38,
+  externalWorkflowExecutionSignaled: 39,
+  upsertWorkflowSearchAttributes: 40,
+  workflowExecutionUpdateAccepted: 41,
+  workflowExecutionUpdateRejected: 42,
+  workflowExecutionUpdateCompleted: 43,
+  workflowPropertiesModifiedExternally: 44,
+  activityPropertiesModifiedExternally: 45,
+  workflowPropertiesModified: 46,
+  workflowExecutionUpdateAdmitted: 47
+};
+var eventTypeNames = new Map([
+  [eventTypes.workflowExecutionStarted, "WorkflowExecutionStarted"],
+  [eventTypes.workflowExecutionCompleted, "WorkflowExecutionCompleted"],
+  [eventTypes.workflowExecutionFailed, "WorkflowExecutionFailed"],
+  [eventTypes.workflowExecutionTimedOut, "WorkflowExecutionTimedOut"],
+  [eventTypes.workflowTaskScheduled, "WorkflowTaskScheduled"],
+  [eventTypes.workflowTaskStarted, "WorkflowTaskStarted"],
+  [eventTypes.workflowTaskCompleted, "WorkflowTaskCompleted"],
+  [eventTypes.workflowTaskTimedOut, "WorkflowTaskTimedOut"],
+  [eventTypes.workflowTaskFailed, "WorkflowTaskFailed"],
+  [eventTypes.activityTaskScheduled, "ActivityTaskScheduled"],
+  [eventTypes.activityTaskStarted, "ActivityTaskStarted"],
+  [eventTypes.activityTaskCompleted, "ActivityTaskCompleted"],
+  [eventTypes.activityTaskFailed, "ActivityTaskFailed"],
+  [eventTypes.activityTaskTimedOut, "ActivityTaskTimedOut"],
+  [eventTypes.activityTaskCancelRequested, "ActivityTaskCancelRequested"],
+  [eventTypes.activityTaskCanceled, "ActivityTaskCanceled"],
+  [eventTypes.timerStarted, "TimerStarted"],
+  [eventTypes.timerFired, "TimerFired"],
+  [eventTypes.timerCanceled, "TimerCanceled"],
+  [eventTypes.workflowExecutionCancelRequested, "WorkflowExecutionCancelRequested"],
+  [eventTypes.workflowExecutionCanceled, "WorkflowExecutionCanceled"],
+  [
+    eventTypes.requestCancelExternalWorkflowExecutionInitiated,
+    "RequestCancelExternalWorkflowExecutionInitiated"
+  ],
+  [
+    eventTypes.requestCancelExternalWorkflowExecutionFailed,
+    "RequestCancelExternalWorkflowExecutionFailed"
+  ],
+  [eventTypes.externalWorkflowExecutionCancelRequested, "ExternalWorkflowExecutionCancelRequested"],
+  [eventTypes.markerRecorded, "MarkerRecorded"],
+  [eventTypes.workflowExecutionSignaled, "WorkflowExecutionSignaled"],
+  [eventTypes.workflowExecutionTerminated, "WorkflowExecutionTerminated"],
+  [eventTypes.workflowExecutionContinuedAsNew, "WorkflowExecutionContinuedAsNew"],
+  [eventTypes.startChildWorkflowExecutionInitiated, "StartChildWorkflowExecutionInitiated"],
+  [eventTypes.startChildWorkflowExecutionFailed, "StartChildWorkflowExecutionFailed"],
+  [eventTypes.childWorkflowExecutionStarted, "ChildWorkflowExecutionStarted"],
+  [eventTypes.childWorkflowExecutionCompleted, "ChildWorkflowExecutionCompleted"],
+  [eventTypes.childWorkflowExecutionFailed, "ChildWorkflowExecutionFailed"],
+  [eventTypes.childWorkflowExecutionCanceled, "ChildWorkflowExecutionCanceled"],
+  [eventTypes.childWorkflowExecutionTimedOut, "ChildWorkflowExecutionTimedOut"],
+  [eventTypes.childWorkflowExecutionTerminated, "ChildWorkflowExecutionTerminated"],
+  [eventTypes.signalExternalWorkflowExecutionInitiated, "SignalExternalWorkflowExecutionInitiated"],
+  [eventTypes.signalExternalWorkflowExecutionFailed, "SignalExternalWorkflowExecutionFailed"],
+  [eventTypes.externalWorkflowExecutionSignaled, "ExternalWorkflowExecutionSignaled"],
+  [eventTypes.upsertWorkflowSearchAttributes, "UpsertWorkflowSearchAttributes"],
+  [eventTypes.workflowExecutionUpdateAccepted, "WorkflowExecutionUpdateAccepted"],
+  [eventTypes.workflowExecutionUpdateRejected, "WorkflowExecutionUpdateRejected"],
+  [eventTypes.workflowExecutionUpdateCompleted, "WorkflowExecutionUpdateCompleted"],
+  [eventTypes.workflowPropertiesModifiedExternally, "WorkflowPropertiesModifiedExternally"],
+  [eventTypes.activityPropertiesModifiedExternally, "ActivityPropertiesModifiedExternally"],
+  [eventTypes.workflowPropertiesModified, "WorkflowPropertiesModified"],
+  [eventTypes.workflowExecutionUpdateAdmitted, "WorkflowExecutionUpdateAdmitted"]
+]);
+function getEventTypeName(eventType) {
+  return eventTypeNames.get(eventType) ?? `UnknownEventType${eventType}`;
+}
+function isKnownEventType(eventType) {
+  return eventTypeNames.has(eventType);
+}
+
+// packages/history/src/history-json.ts
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function readRecordField(value, field) {
+  const candidate = value[field];
+  return isRecord2(candidate) ? candidate : undefined;
+}
+function readArrayField(value, field) {
+  const candidate = value[field];
+  return Array.isArray(candidate) ? candidate : [];
+}
+function readStringField(value, field) {
+  const candidate = value?.[field];
+  return typeof candidate === "string" && candidate.length > 0 ? candidate : undefined;
+}
+function readPositiveIntegerField(value, field) {
+  const candidate = value?.[field];
+  if (typeof candidate === "number" && Number.isInteger(candidate) && candidate > 0) {
+    return candidate;
+  }
+  if (typeof candidate === "string" && /^[1-9]\d*$/.test(candidate)) {
+    return Number(candidate);
+  }
+  return;
+}
+function readHistoryEvent(value, index) {
+  if (!isRecord2(value)) {
+    throw new Error(`History event at index ${index} is not an object.`);
+  }
+  const eventId = readPositiveIntegerField(value, "eventId");
+  const eventType = readPositiveIntegerField(value, "eventType");
+  const eventTime = readStringField(value, "eventTime");
+  if (!eventId) {
+    throw new Error(`History event at index ${index} is missing a positive eventId.`);
+  }
+  if (!eventType) {
+    throw new Error(`History event ${eventId} is missing a positive eventType.`);
+  }
+  if (!eventTime) {
+    throw new Error(`History event ${eventId} is missing eventTime.`);
+  }
+  return {
+    eventId,
+    eventType,
+    eventTypeName: getEventTypeName(eventType),
+    eventTime,
+    raw: value
+  };
+}
+function parseEventHistoryEvents(history) {
+  const events = Array.isArray(history) ? history : isRecord2(history) ? readArrayField(history, "events") : [];
+  if (events.length === 0) {
+    throw new Error("Event History must contain at least one event.");
+  }
+  return events.map((event, index) => readHistoryEvent(event, index)).toSorted((left, right) => left.eventId - right.eventId);
+}
+
+// packages/history/src/payloads.ts
+function decodeBase64(value) {
+  return Buffer.from(value, "base64").toString("utf8");
+}
+function getPayloadEncoding(payload) {
+  const metadata = readRecordField(payload, "metadata");
+  const encoded = readStringField(metadata, "encoding");
+  return encoded ? decodeBase64(encoded) : undefined;
+}
+var redactedPlaceholder = "[REDACTED]";
+function redactString(value, rules, state) {
+  if (rules.patterns.some((pattern) => value.includes(pattern))) {
+    state.redacted = true;
+    return redactedPlaceholder;
+  }
+  return value;
+}
+function redactPreview(value, rules, state) {
+  if (typeof value === "string") {
+    return redactString(value, rules, state);
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => redactPreview(entry, rules, state));
+  }
+  if (isRecord2(value)) {
+    const redacted = {};
+    for (const [key, entry] of Object.entries(value)) {
+      if (rules.keys.has(key)) {
+        state.redacted = true;
+        redacted[key] = redactedPlaceholder;
+      } else {
+        redacted[key] = redactPreview(entry, rules, state);
+      }
+    }
+    return redacted;
+  }
+  return value;
+}
+function decodeJsonPayload(payload, configuration) {
+  const data = readStringField(payload, "data");
+  const maxPreviewBytes = configuration.maxPreviewBytes ?? 0;
+  if (!data || getPayloadEncoding(payload) !== "json/plain") {
+    return { decoded: false };
+  }
+  const decoded = decodeBase64(data);
+  if (maxPreviewBytes <= 0 || Buffer.byteLength(decoded) > maxPreviewBytes) {
+    return { decoded: false };
+  }
+  const rules = {
+    keys: new Set(configuration.redactKeys ?? []),
+    patterns: configuration.redactPatterns ?? []
+  };
+  const state = { redacted: false };
+  const preview = redactPreview(JSON.parse(decoded), rules, state);
+  return {
+    decoded: true,
+    preview,
+    redacted: state.redacted
+  };
+}
+function createPayloadReferences(event, container, kind, configuration) {
+  const payloads = container ? readArrayField(container, "payloads") : [];
+  const shouldDecode = configuration.decodePayloads === true && configuration.redactPayloads !== true;
+  return payloads.map((payload, index) => {
+    const preview = shouldDecode && isRecord2(payload) ? decodeJsonPayload(payload, configuration) : { decoded: false };
+    return {
+      id: `payload:event-${event.eventId}:${kind}:${index}`,
+      eventId: event.eventId,
+      kind,
+      decoded: preview.decoded,
+      ...preview.decoded ? { preview: preview.preview } : {},
+      redacted: preview.decoded ? preview.redacted : true
+    };
+  });
+}
+
+// packages/history/src/references.ts
+function createEventReference(event) {
+  return {
+    eventId: event.eventId,
+    eventType: event.eventTypeName
+  };
+}
+function getDurationMs(startedAt, closedAt) {
+  if (!closedAt) {
+    return;
+  }
+  const duration = Date.parse(closedAt) - Date.parse(startedAt);
+  return Number.isFinite(duration) && duration >= 0 ? duration : undefined;
+}
+function collectPayloadIds(payloads, event, container, kind, configuration) {
+  const references = createPayloadReferences(event, container, kind, configuration);
+  payloads.push(...references);
+  return references.map((reference) => reference.id);
+}
+
+// packages/history/src/activity-operations.ts
+function createActivityOperations(events, payloads, configuration) {
+  return collectActivities(events, payloads, configuration).map(createActivityOperation);
+}
+function collectActivities(events, payloads, configuration) {
+  const activities = new Map;
+  for (const event of events) {
+    recordActivityEvent(event, activities, payloads, configuration);
+  }
+  return [...activities.values()].toSorted((left, right) => left.scheduled.eventId - right.scheduled.eventId);
+}
+function recordActivityEvent(event, activities, payloads, configuration) {
+  if (event.eventType === eventTypes.activityTaskScheduled) {
+    recordScheduledActivity(event, activities, payloads, configuration);
+    return;
+  }
+  recordActivityProgress(event, activities, payloads, configuration);
+}
+function recordScheduledActivity(event, activities, payloads, configuration) {
+  const attributes = readRecordField(event.raw, "activityTaskScheduledEventAttributes");
+  const activityType = readStringField(readRecordField(attributes ?? {}, "activityType"), "name");
+  const activityId = readStringField(attributes, "activityId") ?? String(event.eventId);
+  const input = readRecordField(attributes ?? {}, "input");
+  activities.set(event.eventId, {
+    scheduled: event,
+    activityId,
+    activityType: activityType ?? "unknownActivity",
+    payloadReferences: collectPayloadIds(payloads, event, input, "input", configuration),
+    started: [],
+    closed: []
+  });
+}
+function recordActivityProgress(event, activities, payloads, configuration) {
+  const attributes = getActivityEventAttributes(event);
+  const scheduledEventId = readPositiveIntegerField(attributes, "scheduledEventId");
+  const activity = scheduledEventId ? activities.get(scheduledEventId) : undefined;
+  if (!activity) {
+    return;
+  }
+  if (event.eventType === eventTypes.activityTaskStarted) {
+    activity.started.push(event);
+    return;
+  }
+  const status = getActivityClosedStatus(event.eventType);
+  if (!status) {
+    return;
+  }
+  recordActivityClose(event, activity, attributes, status, payloads, configuration);
+}
+function recordActivityClose(event, activity, attributes, status, payloads, configuration) {
+  const result = readRecordField(attributes ?? {}, status === "failed" ? "failure" : "result");
+  const kind = status === "failed" ? "failure" : "result";
+  activity.closed.push({ event, status });
+  activity.payloadReferences.push(...collectPayloadIds(payloads, event, result, kind, configuration));
+}
+function getActivityEventAttributes(event) {
+  if (event.eventType === eventTypes.activityTaskStarted) {
+    return readRecordField(event.raw, "activityTaskStartedEventAttributes");
+  }
+  if (event.eventType === eventTypes.activityTaskCompleted) {
+    return readRecordField(event.raw, "activityTaskCompletedEventAttributes");
+  }
+  if (event.eventType === eventTypes.activityTaskFailed) {
+    return readRecordField(event.raw, "activityTaskFailedEventAttributes");
+  }
+  if (event.eventType === eventTypes.activityTaskTimedOut) {
+    return readRecordField(event.raw, "activityTaskTimedOutEventAttributes");
+  }
+  if (event.eventType === eventTypes.activityTaskCanceled) {
+    return readRecordField(event.raw, "activityTaskCanceledEventAttributes");
+  }
+  if (event.eventType === eventTypes.activityTaskCancelRequested) {
+    return readRecordField(event.raw, "activityTaskCancelRequestedEventAttributes");
+  }
+  return;
+}
+function getActivityClosedStatus(eventType) {
+  if (eventType === eventTypes.activityTaskCompleted) {
+    return "completed";
+  }
+  if (eventType === eventTypes.activityTaskFailed) {
+    return "failed";
+  }
+  if (eventType === eventTypes.activityTaskTimedOut) {
+    return "timedOut";
+  }
+  if (eventType === eventTypes.activityTaskCanceled) {
+    return "canceled";
+  }
+  return;
+}
+function createActivityOperation(activity) {
+  const lastClosed = activity.closed.at(-1);
+  const eventReferences = [
+    activity.scheduled,
+    ...activity.started,
+    ...activity.closed.map((closed) => closed.event)
+  ].map(createEventReference);
+  return {
+    id: `activity:${activity.activityType}:${activity.scheduled.eventId}`,
+    kind: "activity",
+    activityType: activity.activityType,
+    activityId: activity.activityId,
+    status: lastClosed?.status ?? "pending",
+    attempts: createActivityAttempts(activity),
+    firstScheduledAt: activity.scheduled.eventTime,
+    ...lastClosed ? { closedAt: lastClosed.event.eventTime } : {},
+    ...lastClosed ? { durationMs: getDurationMs(activity.scheduled.eventTime, lastClosed.event.eventTime) } : {},
+    eventReferences,
+    payloadReferences: activity.payloadReferences
+  };
+}
+function readStartedAttemptNumber(started) {
+  if (!started) {
+    return;
+  }
+  const attributes = readRecordField(started.raw, "activityTaskStartedEventAttributes");
+  return readPositiveIntegerField(attributes, "attempt");
+}
+function createActivityAttempts(activity) {
+  if (activity.closed.length === 0) {
+    return [
+      {
+        attempt: readStartedAttemptNumber(activity.started[0]) ?? 1,
+        scheduledEventId: activity.scheduled.eventId,
+        ...activity.started[0] ? { startedEventId: activity.started[0].eventId } : {},
+        status: "pending"
+      }
+    ];
+  }
+  return activity.closed.map((closed, index) => ({
+    attempt: readStartedAttemptNumber(activity.started[index]) ?? index + 1,
+    scheduledEventId: activity.scheduled.eventId,
+    ...activity.started[index] ? { startedEventId: activity.started[index].eventId } : {},
+    closedEventId: closed.event.eventId,
+    status: closed.status
+  }));
+}
+
+// packages/history/src/child-workflow-operations.ts
+var childProgressEvents = new Map([
+  [
+    eventTypes.startChildWorkflowExecutionFailed,
+    { attributesField: "startChildWorkflowExecutionFailedEventAttributes", status: "startFailed" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionStarted,
+    { attributesField: "childWorkflowExecutionStartedEventAttributes", status: "started" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionCompleted,
+    { attributesField: "childWorkflowExecutionCompletedEventAttributes", status: "completed" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionFailed,
+    { attributesField: "childWorkflowExecutionFailedEventAttributes", status: "failed" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionCanceled,
+    { attributesField: "childWorkflowExecutionCanceledEventAttributes", status: "canceled" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionTimedOut,
+    { attributesField: "childWorkflowExecutionTimedOutEventAttributes", status: "timedOut" }
+  ],
+  [
+    eventTypes.childWorkflowExecutionTerminated,
+    { attributesField: "childWorkflowExecutionTerminatedEventAttributes", status: "terminated" }
+  ]
+]);
+function recordInitiatedChild(event, children, payloads, configuration) {
+  const attributes = readRecordField(event.raw, "startChildWorkflowExecutionInitiatedEventAttributes");
+  const workflowType = readStringField(readRecordField(attributes ?? {}, "workflowType"), "name") ?? "unknownChildWorkflow";
+  children.set(event.eventId, {
+    initiated: event,
+    workflowType,
+    childWorkflowId: readStringField(attributes, "workflowId") ?? String(event.eventId),
+    payloadReferences: collectPayloadIds(payloads, event, readRecordField(attributes ?? {}, "input"), "input", configuration),
+    progress: []
+  });
+}
+function recordChildClosePayloads(event, child, attributes, status, payloads, configuration) {
+  if (status !== "completed" && status !== "failed") {
+    return;
+  }
+  const field = status === "completed" ? "result" : "failure";
+  child.payloadReferences.push(...collectPayloadIds(payloads, event, readRecordField(attributes ?? {}, field), field, configuration));
+}
+function recordChildProgress(event, children, payloads, configuration) {
+  const progressKind = childProgressEvents.get(event.eventType);
+  if (!progressKind) {
+    return;
+  }
+  const attributes = readRecordField(event.raw, progressKind.attributesField);
+  const initiatedEventId = readPositiveIntegerField(attributes, "initiatedEventId");
+  const child = initiatedEventId ? children.get(initiatedEventId) : undefined;
+  if (!child) {
+    return;
+  }
+  child.progress.push({ event, status: progressKind.status });
+  const runId = readStringField(readRecordField(attributes ?? {}, "workflowExecution"), "runId");
+  if (runId && !child.childRunId) {
+    child.childRunId = runId;
+  }
+  recordChildClosePayloads(event, child, attributes, progressKind.status, payloads, configuration);
+}
+function isClosedStatus(status) {
+  return status !== "started";
+}
+function createChildWorkflowOperations(events, payloads, configuration) {
+  const children = new Map;
+  for (const event of events) {
+    if (event.eventType === eventTypes.startChildWorkflowExecutionInitiated) {
+      recordInitiatedChild(event, children, payloads, configuration);
+    } else {
+      recordChildProgress(event, children, payloads, configuration);
+    }
+  }
+  return [...children.values()].toSorted((left, right) => left.initiated.eventId - right.initiated.eventId).map((child) => {
+    const closed = child.progress.findLast((entry) => isClosedStatus(entry.status));
+    return {
+      id: `child-workflow:${child.workflowType}:${child.initiated.eventId}`,
+      kind: "child-workflow",
+      workflowType: child.workflowType,
+      childWorkflowId: child.childWorkflowId,
+      ...child.childRunId ? { childRunId: child.childRunId } : {},
+      status: closed?.status ?? child.progress.at(-1)?.status ?? "initiated",
+      initiatedAt: child.initiated.eventTime,
+      ...closed ? { closedAt: closed.event.eventTime } : {},
+      eventReferences: [
+        createEventReference(child.initiated),
+        ...child.progress.map((entry) => createEventReference(entry.event))
+      ],
+      payloadReferences: child.payloadReferences
+    };
+  });
+}
+
+// packages/history/src/diagnostics.ts
+function createUnknownEventDiagnostics(events) {
+  return events.filter((event) => !isKnownEventType(event.eventType)).map((event) => ({
+    code: "TEH_UNKNOWN_EVENT_TYPE",
+    category: "history",
+    severity: "warning",
+    message: `Unsupported Event History event type ${event.eventType} at event ${event.eventId}.`,
+    confidence: "unknown"
+  }));
+}
+
+// packages/history/src/external-signal-operations.ts
+function recordInitiatedExternalSignal(event, signals, payloads, configuration) {
+  const attributes = readRecordField(event.raw, "signalExternalWorkflowExecutionInitiatedEventAttributes");
+  const execution = readRecordField(attributes ?? {}, "workflowExecution");
+  signals.set(event.eventId, {
+    initiated: event,
+    signalName: readStringField(attributes, "signalName") ?? "unknownSignal",
+    targetWorkflowId: readStringField(execution, "workflowId") ?? "unknown-workflow-id",
+    payloadReferences: collectPayloadIds(payloads, event, readRecordField(attributes ?? {}, "input"), "signal", configuration)
+  });
+}
+function recordExternalSignalClose(event, signals, status, attributesField) {
+  const attributes = readRecordField(event.raw, attributesField);
+  const initiatedEventId = readPositiveIntegerField(attributes, "initiatedEventId");
+  const signal = initiatedEventId ? signals.get(initiatedEventId) : undefined;
+  if (!signal) {
+    return;
+  }
+  signal.closed = { event, status };
+  const runId = readStringField(readRecordField(attributes ?? {}, "workflowExecution"), "runId");
+  if (runId) {
+    signal.targetRunId = runId;
+  }
+}
+function createExternalSignalOperations(events, payloads, configuration) {
+  const signals = new Map;
+  for (const event of events) {
+    if (event.eventType === eventTypes.signalExternalWorkflowExecutionInitiated) {
+      recordInitiatedExternalSignal(event, signals, payloads, configuration);
+    } else if (event.eventType === eventTypes.externalWorkflowExecutionSignaled) {
+      recordExternalSignalClose(event, signals, "signaled", "externalWorkflowExecutionSignaledEventAttributes");
+    } else if (event.eventType === eventTypes.signalExternalWorkflowExecutionFailed) {
+      recordExternalSignalClose(event, signals, "failed", "signalExternalWorkflowExecutionFailedEventAttributes");
+    }
+  }
+  return [...signals.values()].toSorted((left, right) => left.initiated.eventId - right.initiated.eventId).map((signal) => ({
+    id: `external-signal:${signal.signalName}:${signal.initiated.eventId}`,
+    kind: "external-signal",
+    signalName: signal.signalName,
+    targetWorkflowId: signal.targetWorkflowId,
+    ...signal.targetRunId ? { targetRunId: signal.targetRunId } : {},
+    status: signal.closed?.status ?? "initiated",
+    initiatedAt: signal.initiated.eventTime,
+    ...signal.closed ? { closedAt: signal.closed.event.eventTime } : {},
+    eventReferences: [
+      createEventReference(signal.initiated),
+      ...signal.closed ? [createEventReference(signal.closed.event)] : []
+    ],
+    payloadReferences: signal.payloadReferences
+  }));
+}
+
+// packages/history/src/marker-operations.ts
+function readPatchDetails(attributes) {
+  const details = readRecordField(attributes ?? {}, "details");
+  const patchData = readRecordField(details ?? {}, "patch-data");
+  const [payload] = readArrayField(patchData ?? {}, "payloads");
+  if (!isRecord2(payload)) {
+    return;
+  }
+  const data = readStringField(payload, "data");
+  if (!data) {
+    return;
+  }
+  try {
+    const decoded = JSON.parse(Buffer.from(data, "base64").toString("utf8"));
+    if (isRecord2(decoded) && typeof decoded["id"] === "string") {
+      return {
+        patchId: decoded["id"],
+        deprecated: decoded["deprecated"] === true
+      };
+    }
+  } catch {
+    return;
+  }
+  return;
+}
+function createMarkerOperations(events) {
+  return events.filter((event) => event.eventType === eventTypes.markerRecorded).map((event) => {
+    const attributes = readRecordField(event.raw, "markerRecordedEventAttributes");
+    const markerName = readStringField(attributes, "markerName") ?? "unknownMarker";
+    const patch = markerName === "core_patch" ? readPatchDetails(attributes) : undefined;
+    return {
+      id: `marker:${markerName}:${event.eventId}`,
+      kind: "marker",
+      markerName,
+      ...patch ? { patchId: patch.patchId, deprecated: patch.deprecated } : {},
+      recordedAt: event.eventTime,
+      eventReferences: [createEventReference(event)]
+    };
+  });
+}
+
+// packages/history/src/signal-operations.ts
+function createSignalOperations(events, payloads, configuration) {
+  return events.filter((event) => event.eventType === eventTypes.workflowExecutionSignaled).map((event) => {
+    const attributes = readRecordField(event.raw, "workflowExecutionSignaledEventAttributes");
+    const signalName = readStringField(attributes, "signalName") ?? "unknownSignal";
+    const input = readRecordField(attributes ?? {}, "input");
+    return {
+      id: `signal:${signalName}:${event.eventId}`,
+      kind: "signal",
+      signalName,
+      receivedAt: event.eventTime,
+      eventReferences: [createEventReference(event)],
+      payloadReferences: collectPayloadIds(payloads, event, input, "signal", configuration)
+    };
+  });
+}
+
+// packages/history/src/workflow-lifecycle.ts
+function createWorkflowLifecycle(events, payloads, configuration, provenance) {
+  const workflowStartedEvent = getWorkflowStartedEvent(events);
+  const workflowClosedEvent = findWorkflowClosedEvent(events);
+  const workflowStartedAttributes = readRecordField(workflowStartedEvent.raw, "workflowExecutionStartedEventAttributes");
+  const workflowType = getWorkflowType(workflowStartedAttributes, provenance);
+  const runId = readStringField(workflowStartedAttributes, "originalExecutionRunId") ?? "unknown-run-id";
+  const workflowId = provenance?.workflowId ?? `${workflowType}-${runId}`;
+  const startPayloads = collectPayloadIds(payloads, workflowStartedEvent, readRecordField(workflowStartedAttributes ?? {}, "input"), "input", configuration);
+  const closePayloads = collectWorkflowClosePayloads(payloads, workflowClosedEvent, configuration);
+  return {
+    workflowStartedEvent,
+    ...workflowClosedEvent ? { workflowClosedEvent } : {},
+    workflowStartedAttributes,
+    workflowType,
+    workflowId,
+    runId,
+    operations: createWorkflowOperations(workflowStartedEvent, workflowClosedEvent, startPayloads, closePayloads)
+  };
+}
+var closedStatusByEventType = new Map([
+  [eventTypes.workflowExecutionCompleted, "completed"],
+  [eventTypes.workflowExecutionFailed, "failed"],
+  [eventTypes.workflowExecutionCanceled, "canceled"],
+  [eventTypes.workflowExecutionTerminated, "terminated"],
+  [eventTypes.workflowExecutionContinuedAsNew, "continued-as-new"]
+]);
+function getWorkflowClosedStatus(eventType) {
+  return closedStatusByEventType.get(eventType) ?? "timedOut";
+}
+function createWorkflowExecution(lifecycle) {
+  const closedEvent = lifecycle.workflowClosedEvent;
+  return {
+    workflowType: lifecycle.workflowType,
+    workflowId: lifecycle.workflowId,
+    runId: lifecycle.runId,
+    status: closedEvent ? getWorkflowClosedStatus(closedEvent.eventType) : "running",
+    startedAt: lifecycle.workflowStartedEvent.eventTime,
+    ...closedEvent ? { closedAt: closedEvent.eventTime } : {},
+    ...closedEvent ? {
+      durationMs: getDurationMs(lifecycle.workflowStartedEvent.eventTime, closedEvent.eventTime)
+    } : {}
+  };
+}
+function getWorkflowStartedEvent(events) {
+  const event = events.find((candidate) => candidate.eventType === eventTypes.workflowExecutionStarted);
+  if (!event) {
+    throw new Error("Event History is missing WorkflowExecutionStarted.");
+  }
+  return event;
+}
+function getWorkflowType(attributes, provenance) {
+  return provenance?.workflowType ?? readStringField(readRecordField(attributes ?? {}, "workflowType"), "name") ?? "unknownWorkflow";
+}
+function findWorkflowClosedEvent(events) {
+  const closedEventTypes = new Set([
+    eventTypes.workflowExecutionCompleted,
+    eventTypes.workflowExecutionFailed,
+    eventTypes.workflowExecutionTimedOut,
+    eventTypes.workflowExecutionCanceled,
+    eventTypes.workflowExecutionTerminated,
+    eventTypes.workflowExecutionContinuedAsNew
+  ]);
+  return events.find((event) => closedEventTypes.has(event.eventType));
+}
+var closePayloadFields = new Map([
+  [
+    eventTypes.workflowExecutionCompleted,
+    {
+      attributesField: "workflowExecutionCompletedEventAttributes",
+      container: "result",
+      kind: "result"
+    }
+  ],
+  [
+    eventTypes.workflowExecutionFailed,
+    {
+      attributesField: "workflowExecutionFailedEventAttributes",
+      container: "failure",
+      kind: "failure"
+    }
+  ],
+  [
+    eventTypes.workflowExecutionCanceled,
+    {
+      attributesField: "workflowExecutionCanceledEventAttributes",
+      container: "details",
+      kind: "result"
+    }
+  ],
+  [
+    eventTypes.workflowExecutionContinuedAsNew,
+    {
+      attributesField: "workflowExecutionContinuedAsNewEventAttributes",
+      container: "input",
+      kind: "input"
+    }
+  ]
+]);
+function collectWorkflowClosePayloads(payloads, closed, configuration) {
+  const fields = closed ? closePayloadFields.get(closed.eventType) : undefined;
+  if (!closed || !fields) {
+    return [];
+  }
+  const attributes = readRecordField(closed.raw, fields.attributesField);
+  return collectPayloadIds(payloads, closed, readRecordField(attributes ?? {}, fields.container), fields.kind, configuration);
+}
+function createCancelRequestOperations(events) {
+  return events.filter((event) => event.eventType === eventTypes.workflowExecutionCancelRequested).map((event) => ({
+    id: `cancel-request:${event.eventId}`,
+    kind: "cancel-request",
+    requestedAt: event.eventTime,
+    eventReferences: [createEventReference(event)]
+  }));
+}
+function createContinueAsNewOperations(events, payloads, configuration) {
+  return events.filter((event) => event.eventType === eventTypes.workflowExecutionContinuedAsNew).map((event) => {
+    const attributes = readRecordField(event.raw, "workflowExecutionContinuedAsNewEventAttributes");
+    const newRunId = readStringField(attributes, "newExecutionRunId");
+    return {
+      id: `continue-as-new:${event.eventId}`,
+      kind: "continue-as-new",
+      ...newRunId ? { newRunId } : {},
+      occurredAt: event.eventTime,
+      eventReferences: [createEventReference(event)],
+      payloadReferences: collectPayloadIds(payloads, event, readRecordField(attributes ?? {}, "input"), "input", configuration)
+    };
+  });
+}
+function createWorkflowOperations(started, closed, startPayloads, closePayloads) {
+  const operations = [
+    {
+      id: "workflow:start",
+      kind: "workflow-lifecycle",
+      status: "started",
+      eventReferences: [createEventReference(started)],
+      payloadReferences: startPayloads
+    }
+  ];
+  if (closed) {
+    const closedStatus = getWorkflowClosedStatus(closed.eventType);
+    operations.push({
+      id: `workflow:${closedStatus}`,
+      kind: "workflow-lifecycle",
+      status: closedStatus === "running" ? "completed" : closedStatus,
+      eventReferences: [createEventReference(closed)],
+      payloadReferences: closePayloads
+    });
+  }
+  return operations;
+}
+
+// packages/history/src/timeline.ts
+function openCloseSpans(operation, openAt, openLabel, closedAt, closedLabel) {
+  const opened = operation.eventReferences[0];
+  const closed = operation.eventReferences.at(-1);
+  const spans = [{ at: openAt, label: openLabel, reference: opened }];
+  if (closedAt && closed && closed !== opened) {
+    spans.push({ at: closedAt, label: closedLabel, reference: closed });
+  }
+  return spans;
+}
+function activitySpans(operation) {
+  return openCloseSpans(operation, operation.firstScheduledAt, `${operation.activityType} scheduled`, operation.closedAt, `${operation.activityType} ${operation.status}`);
+}
+function pointSpan(operation, at, label) {
+  return [{ at, label, reference: operation.eventReferences[0] }];
+}
+function markerLabel(operation) {
+  if (!operation.patchId) {
+    return `Marker ${operation.markerName}`;
+  }
+  return `Patch ${operation.patchId}${operation.deprecated ? " (deprecated)" : ""}`;
+}
+function pointOperationSpans(operation) {
+  switch (operation.kind) {
+    case "signal":
+      return pointSpan(operation, operation.receivedAt, `Signal ${operation.signalName} received`);
+    case "marker":
+      return pointSpan(operation, operation.recordedAt, markerLabel(operation));
+    case "continue-as-new":
+      return pointSpan(operation, operation.occurredAt, "Continued as new");
+    case "cancel-request":
+      return pointSpan(operation, operation.requestedAt, "Cancellation requested");
+    default:
+      return [];
+  }
+}
+function operationSpans(operation) {
+  switch (operation.kind) {
+    case "activity":
+      return activitySpans(operation);
+    case "timer":
+      return openCloseSpans(operation, operation.startedAt, `Timer ${operation.timerId} started`, operation.closedAt, `Timer ${operation.timerId} ${operation.status}`);
+    case "update":
+      return openCloseSpans(operation, operation.acceptedAt, `Update ${operation.updateName} accepted`, operation.closedAt, `Update ${operation.updateName} ${operation.status}`);
+    case "child-workflow":
+      return openCloseSpans(operation, operation.initiatedAt, `Child ${operation.workflowType} initiated`, operation.closedAt, `Child ${operation.workflowType} ${operation.status}`);
+    case "external-signal":
+      return openCloseSpans(operation, operation.initiatedAt, `External signal ${operation.signalName} initiated`, operation.closedAt, `External signal ${operation.signalName} ${operation.status}`);
+    default:
+      return pointOperationSpans(operation);
+  }
+}
+function createTimeline(started, closed, operations) {
+  const entries = [
+    {
+      id: `timeline:${started.eventId}`,
+      operationId: "workflow:start",
+      at: started.eventTime,
+      label: "Workflow started",
+      eventIds: [started.eventId]
+    }
+  ];
+  for (const operation of operations) {
+    for (const span of operationSpans(operation)) {
+      if (span.reference) {
+        entries.push({
+          id: `timeline:${span.reference.eventId}`,
+          operationId: operation.id,
+          at: span.at,
+          label: span.label,
+          eventIds: [span.reference.eventId]
+        });
+      }
+    }
+  }
+  if (closed) {
+    entries.push({
+      id: `timeline:${closed.eventId}`,
+      operationId: `workflow:${getWorkflowClosedStatus(closed.eventType)}`,
+      at: closed.eventTime,
+      label: "Workflow closed",
+      eventIds: [closed.eventId]
+    });
+  }
+  return entries.toSorted((left, right) => Date.parse(left.at) - Date.parse(right.at));
+}
+
+// packages/history/src/timer-operations.ts
+function readDurationText(attributes) {
+  const timeout = readRecordField(attributes ?? {}, "startToFireTimeout");
+  if (!timeout) {
+    return;
+  }
+  const seconds = timeout["seconds"];
+  if (typeof seconds === "string" || typeof seconds === "number") {
+    return `${seconds}s`;
+  }
+  return;
+}
+function recordTimerClose(event, timers, attributesField, status) {
+  const attributes = readRecordField(event.raw, attributesField);
+  const startedEventId = readPositiveIntegerField(attributes, "startedEventId");
+  const timer = startedEventId ? timers.get(startedEventId) : undefined;
+  if (timer) {
+    timer.closed = { event, status };
+  }
+}
+function createTimerOperations(events) {
+  const timers = new Map;
+  for (const event of events) {
+    if (event.eventType === eventTypes.timerStarted) {
+      const attributes = readRecordField(event.raw, "timerStartedEventAttributes");
+      const durationText = readDurationText(attributes);
+      timers.set(event.eventId, {
+        started: event,
+        timerId: readStringField(attributes, "timerId") ?? String(event.eventId),
+        ...durationText ? { durationText } : {}
+      });
+      continue;
+    }
+    if (event.eventType === eventTypes.timerFired) {
+      recordTimerClose(event, timers, "timerFiredEventAttributes", "fired");
+      continue;
+    }
+    if (event.eventType === eventTypes.timerCanceled) {
+      recordTimerClose(event, timers, "timerCanceledEventAttributes", "canceled");
+    }
+  }
+  return [...timers.values()].toSorted((left, right) => left.started.eventId - right.started.eventId).map((timer) => ({
+    id: `timer:${timer.timerId}:${timer.started.eventId}`,
+    kind: "timer",
+    timerId: timer.timerId,
+    status: timer.closed?.status ?? "pending",
+    startedAt: timer.started.eventTime,
+    ...timer.closed ? { closedAt: timer.closed.event.eventTime } : {},
+    ...timer.durationText ? { durationText: timer.durationText } : {},
+    eventReferences: [
+      { eventId: timer.started.eventId, eventType: timer.started.eventTypeName },
+      ...timer.closed ? [{ eventId: timer.closed.event.eventId, eventType: timer.closed.event.eventTypeName }] : []
+    ]
+  }));
+}
+
+// packages/history/src/update-operations.ts
+function recordAcceptedUpdate(event, updates, payloads, configuration) {
+  const attributes = readRecordField(event.raw, "workflowExecutionUpdateAcceptedEventAttributes");
+  const acceptedRequest = readRecordField(attributes ?? {}, "acceptedRequest");
+  const meta = readRecordField(acceptedRequest ?? {}, "meta");
+  const input = readRecordField(acceptedRequest ?? {}, "input");
+  const updateId = readStringField(meta, "updateId") ?? String(event.eventId);
+  const updateName = readStringField(input, "name") ?? "unknownUpdate";
+  updates.set(updateId, {
+    accepted: event,
+    updateId,
+    updateName,
+    payloadReferences: collectPayloadIds(payloads, event, readRecordField(input ?? {}, "args"), "update", configuration)
+  });
+}
+function recordCompletedUpdate(event, updates, payloads, configuration) {
+  const attributes = readRecordField(event.raw, "workflowExecutionUpdateCompletedEventAttributes");
+  const updateId = readStringField(readRecordField(attributes ?? {}, "meta"), "updateId");
+  const update = updateId ? updates.get(updateId) : undefined;
+  if (!update) {
+    return;
+  }
+  const outcome = readRecordField(attributes ?? {}, "outcome");
+  const success = readRecordField(outcome ?? {}, "success");
+  const status = success ? "completed" : "failed";
+  update.closed = { event, status };
+  update.payloadReferences.push(...collectPayloadIds(payloads, event, success, status === "completed" ? "result" : "failure", configuration));
+}
+function createUpdateOperations(events, payloads, configuration) {
+  const updates = new Map;
+  for (const event of events) {
+    if (event.eventType === eventTypes.workflowExecutionUpdateAccepted) {
+      recordAcceptedUpdate(event, updates, payloads, configuration);
+    } else if (event.eventType === eventTypes.workflowExecutionUpdateCompleted) {
+      recordCompletedUpdate(event, updates, payloads, configuration);
+    }
+  }
+  return [...updates.values()].toSorted((left, right) => left.accepted.eventId - right.accepted.eventId).map((update) => ({
+    id: `update:${update.updateName}:${update.accepted.eventId}`,
+    kind: "update",
+    updateId: update.updateId,
+    updateName: update.updateName,
+    status: update.closed?.status ?? "accepted",
+    acceptedAt: update.accepted.eventTime,
+    ...update.closed ? { closedAt: update.closed.event.eventTime } : {},
+    eventReferences: [
+      createEventReference(update.accepted),
+      ...update.closed ? [createEventReference(update.closed.event)] : []
+    ],
+    payloadReferences: update.payloadReferences
+  }));
+}
+
+// packages/history/src/trace-builder.ts
+function createMetadata(options) {
+  return {
+    temporalExplorerVersion: "0.0.0-mvp",
+    schemaVersion: "temporal-trace/v1",
+    inputs: {
+      projectRoot: options.projectRoot ?? "",
+      configHash: options.historyHash ?? "",
+      sourceFileHashes: {},
+      temporalSdkVersions: options.provenance?.temporalSdkVersion ? { "@temporalio/workflow": options.provenance.temporalSdkVersion } : {}
+    }
+  };
+}
+function createSource(lifecycle, eventCount, importedFrom) {
+  const taskQueue = readStringField(readRecordField(lifecycle.workflowStartedAttributes ?? {}, "taskQueue"), "name");
+  return {
+    ...taskQueue ? { taskQueue } : {},
+    eventCount,
+    importedFrom: importedFrom ?? "file"
+  };
+}
+function parseEventHistory(options) {
+  const events = parseEventHistoryEvents(options.history);
+  const payloads = [];
+  const configuration = options.payloadPreview ?? {};
+  const lifecycle = createWorkflowLifecycle(events, payloads, configuration, options.provenance);
+  const detailOperations = [
+    ...createActivityOperations(events, payloads, configuration),
+    ...createSignalOperations(events, payloads, configuration),
+    ...createTimerOperations(events),
+    ...createUpdateOperations(events, payloads, configuration),
+    ...createChildWorkflowOperations(events, payloads, configuration),
+    ...createExternalSignalOperations(events, payloads, configuration),
+    ...createMarkerOperations(events),
+    ...createCancelRequestOperations(events),
+    ...createContinueAsNewOperations(events, payloads, configuration)
+  ];
+  return {
+    schemaVersion: "temporal-trace/v1",
+    artifactId: `trace:${options.traceId ?? lifecycle.workflowType}:${lifecycle.runId}`,
+    metadata: createMetadata(options),
+    execution: createWorkflowExecution(lifecycle),
+    source: createSource(lifecycle, events.length, options.importedFrom),
+    operations: [...lifecycle.operations, ...detailOperations],
+    timeline: createTimeline(lifecycle.workflowStartedEvent, lifecycle.workflowClosedEvent, detailOperations),
+    payloads,
+    diagnostics: createUnknownEventDiagnostics(events)
+  };
+}
+
+// packages/history/src/live.ts
+import { Client, Connection } from "@temporalio/client";
+
+// packages/history/src/proto-history.ts
+import { Buffer as Buffer2 } from "buffer";
+function isLongLike(value) {
+  const constructorName = value.constructor?.name;
+  return constructorName === "Long";
+}
+function isProtoTimestamp(value) {
+  return "seconds" in value && !("metadata" in value) && Object.keys(value).length <= 2;
+}
+function toNumeric(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return Number(value);
+  }
+  if (value && typeof value === "object" && isLongLike(value)) {
+    return Number(value.toString());
+  }
+  return 0;
+}
+function toIsoTime(value) {
+  const seconds = toNumeric(value["seconds"]);
+  const nanos = toNumeric(value["nanos"]);
+  return new Date(seconds * 1000 + Math.floor(nanos / 1e6)).toISOString();
+}
+function convertRecord(value, key) {
+  if (key === "eventTime" && isProtoTimestamp(value)) {
+    return toIsoTime(value);
+  }
+  const converted = {};
+  for (const [childKey, childValue] of Object.entries(value)) {
+    if (childValue !== undefined && childValue !== null) {
+      converted[childKey] = convertValue(childValue, childKey);
+    }
+  }
+  return converted;
+}
+function convertValue(value, key) {
+  if (value instanceof Uint8Array) {
+    return Buffer2.from(value).toString("base64");
+  }
+  if (value && typeof value === "object" && isLongLike(value)) {
+    return value.toString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => convertValue(item));
+  }
+  if (isRecord2(value)) {
+    return convertRecord(value, key);
+  }
+  return value;
+}
+function convertProtoHistory(history) {
+  return convertValue(history);
+}
+
+// packages/history/src/live.ts
+async function createLiveClient(options) {
+  const namespace = options.namespace ?? "default";
+  const connection = await Connection.connect({
+    address: options.address,
+    ...options.apiKey ? { apiKey: options.apiKey } : {},
+    ...options.tls?.enabled ? {
+      tls: options.tls.serverNameOverride ? { serverNameOverride: options.tls.serverNameOverride } : true
+    } : {}
+  });
+  return {
+    client: new Client({ connection, namespace }),
+    namespace,
+    close: async () => {
+      await connection.close();
+    }
+  };
+}
+function buildListQuery(options) {
+  if (options.query) {
+    return options.query;
+  }
+  const clauses = [];
+  if (options.workflowType) {
+    clauses.push(`WorkflowType='${options.workflowType}'`);
+  }
+  if (options.workflowId) {
+    clauses.push(`WorkflowId='${options.workflowId}'`);
+  }
+  if (options.status) {
+    clauses.push(`ExecutionStatus='${options.status}'`);
+  }
+  return clauses.length > 0 ? clauses.join(" AND ") : undefined;
+}
+async function listWorkflowRuns(options) {
+  const query = buildListQuery(options);
+  const limit = options.limit ?? 50;
+  const runs = [];
+  for await (const execution of options.client.workflow.list(query ? { query } : {})) {
+    runs.push({
+      workflowId: execution.workflowId,
+      runId: execution.runId,
+      workflowType: execution.type,
+      status: execution.status.name,
+      ...execution.startTime ? { startedAt: execution.startTime.toISOString() } : {},
+      ...execution.closeTime ? { closedAt: execution.closeTime.toISOString() } : {},
+      ...execution.taskQueue ? { taskQueue: execution.taskQueue } : {}
+    });
+    if (runs.length >= limit) {
+      break;
+    }
+  }
+  return runs;
+}
+async function fetchEventHistory(options) {
+  const handle = options.client.workflow.getHandle(options.workflowId, options.runId);
+  const description = await handle.describe();
+  const history = convertProtoHistory(await handle.fetchHistory());
+  const { client: _client, workflowId, runId, ...parseOptions } = options;
+  const trace = parseEventHistory({
+    ...parseOptions,
+    history,
+    importedFrom: "api",
+    traceId: options.traceId ?? `${workflowId}.${description.runId}`,
+    provenance: options.provenance ?? {
+      workflowId,
+      workflowType: description.type
+    }
+  });
+  return { trace, runId: description.runId };
+}
+
+// packages/history/src/index.ts
+async function hashFile2(path) {
+  const bytes = await Bun.file(path).bytes();
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function toProjectPath2(root, path) {
+  return root ? relative2(root, path) || "." : path;
+}
+function getProvenancePath(historyPath) {
+  const historyName = basename2(historyPath, ".json");
+  return join(dirname(historyPath), `${historyName}.provenance.json`);
+}
+function readHistoryProvenance(value) {
+  if (!isRecord2(value)) {
+    return;
+  }
+  const workflowId = readStringField(value, "workflowId");
+  const workflowType = readStringField(value, "workflowType");
+  const temporalSdkVersion = readStringField(value, "temporalSdkVersion");
+  const provenance = {};
+  if (workflowId) {
+    provenance.workflowId = workflowId;
+  }
+  if (workflowType) {
+    provenance.workflowType = workflowType;
+  }
+  if (temporalSdkVersion) {
+    provenance.temporalSdkVersion = temporalSdkVersion;
+  }
+  return provenance;
+}
+async function readOptionalProvenance(historyPath) {
+  const provenanceFile = Bun.file(getProvenancePath(historyPath));
+  if (!await provenanceFile.exists()) {
+    return;
+  }
+  return readHistoryProvenance(await provenanceFile.json());
+}
+async function importEventHistoryFile(options) {
+  const historyPath = resolve4(options.file);
+  const projectRoot = options.projectRoot ? resolve4(options.projectRoot) : undefined;
+  const history = await Bun.file(historyPath).json();
+  const provenance = options.provenance ?? await readOptionalProvenance(historyPath);
+  const parseOptions = {
+    history,
+    historyPath: toProjectPath2(projectRoot, historyPath),
+    historyHash: options.historyHash ?? await hashFile2(historyPath),
+    traceId: options.traceId ?? basename2(historyPath, ".json")
+  };
+  if (options.importedFrom) {
+    parseOptions.importedFrom = options.importedFrom;
+  }
+  if (options.payloadPreview) {
+    parseOptions.payloadPreview = options.payloadPreview;
+  }
+  if (projectRoot) {
+    parseOptions.projectRoot = basename2(projectRoot);
+  }
+  if (provenance) {
+    parseOptions.provenance = provenance;
+  }
+  return parseEventHistory(parseOptions);
+}
+
+// packages/mapper/src/construct-mappings.ts
+function getEventIds(operation) {
+  return operation.eventReferences.map((reference) => reference.eventId);
+}
+function createUnmappedMapping(operation, reason) {
+  return {
+    runtimeOperationId: operation.id,
+    confidence: "unknown",
+    reason,
+    evidence: [
+      {
+        kind: "unmapped",
+        description: reason,
+        eventIds: getEventIds(operation)
+      }
+    ]
+  };
+}
+function createCommandMapping(operation, command, confidence, reason, evidenceKind, evidenceDescription) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: command.id,
+    confidence,
+    reason,
+    evidence: [
+      {
+        kind: evidenceKind,
+        description: evidenceDescription,
+        eventIds: getEventIds(operation),
+        staticNodeId: command.id
+      },
+      {
+        kind: "source-location",
+        description: `Static source is ${command.source.path}:${command.source.start.line}.`,
+        staticNodeId: command.id
+      }
+    ]
+  };
+}
+function mapUpdateOperation(operation, updates) {
+  const update = updates.find((candidate) => candidate.name === operation.updateName);
+  if (!update) {
+    return createUnmappedMapping(operation, `No static Update definition matched ${operation.updateName}.`);
+  }
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: update.id,
+    confidence: "exact",
+    reason: `Update ${operation.updateName} matched a static Update definition by name.`,
+    evidence: [
+      {
+        kind: "update-name",
+        description: `Runtime Update ${operation.updateName} matched static Update ${update.name}.`,
+        eventIds: getEventIds(operation),
+        staticNodeId: update.id
+      },
+      {
+        kind: "source-location",
+        description: `Static Update source is ${update.source.path}:${update.source.start.line}.`,
+        staticNodeId: update.id
+      }
+    ]
+  };
+}
+function mapChildWorkflowOperation(operation, childCommands, occurrences) {
+  const occurrence = occurrences.get(operation.workflowType) ?? 0;
+  occurrences.set(operation.workflowType, occurrence + 1);
+  const command = childCommands.filter((candidate) => candidate.name === operation.workflowType)[occurrence];
+  if (!command) {
+    return createUnmappedMapping(operation, `No static child Workflow command matched ${operation.workflowType} occurrence ${occurrence + 1}.`);
+  }
+  return createCommandMapping(operation, command, "exact", `Child Workflow ${operation.workflowType} matched by Workflow type and command order.`, "child-workflow-type", `Runtime child Workflow type ${operation.workflowType} matched static command ${command.id}.`);
+}
+function mapExternalSignalOperation(operation, externalCommands, occurrences) {
+  const occurrence = occurrences.get(operation.signalName) ?? 0;
+  occurrences.set(operation.signalName, occurrence + 1);
+  const command = externalCommands.filter((candidate) => candidate.name === operation.signalName)[occurrence];
+  if (!command) {
+    return createUnmappedMapping(operation, `No static external Workflow command matched signal ${operation.signalName}.`);
+  }
+  return createCommandMapping(operation, command, "exact", `External signal ${operation.signalName} matched by signal name.`, "external-signal-name", `Runtime external signal ${operation.signalName} matched static command ${command.id}.`);
+}
+function mapMarkerOperation(operation, patchCommands) {
+  if (!operation.patchId) {
+    return createUnmappedMapping(operation, `Marker ${operation.markerName} has no static counterpart.`);
+  }
+  const command = patchCommands.find((candidate) => candidate.name === operation.patchId);
+  if (!command) {
+    return createUnmappedMapping(operation, `No static patch matched patch ID ${operation.patchId}.`);
+  }
+  return createCommandMapping(operation, command, "exact", `Patch marker ${operation.patchId} matched a static patch call by patch ID.`, "patch-id", `Runtime patch marker ${operation.patchId} matched static patch ${command.id}.`);
+}
+function mapContinueAsNewOperation(operation, continueAsNewCommands) {
+  const [command] = continueAsNewCommands;
+  if (!command) {
+    return createUnmappedMapping(operation, "No static continue-as-new call matched the runtime rollover.");
+  }
+  return createCommandMapping(operation, command, continueAsNewCommands.length === 1 ? "exact" : "inferred", "Continue-as-new matched the static continue-as-new call.", "continue-as-new", `Runtime continue-as-new matched static command ${command.id}.`);
+}
+function mapCancelRequestOperation(operation, workflow) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: workflow.id,
+    confidence: "exact",
+    reason: "Cancellation was requested for the Workflow Execution.",
+    evidence: [
+      {
+        kind: "workflow-type",
+        description: `Cancellation request belongs to Workflow ${workflow.name}.`,
+        eventIds: getEventIds(operation),
+        staticNodeId: workflow.id
+      }
+    ]
+  };
+}
+function mapDynamicActivityFallback(operation, dynamicCommands) {
+  const [command] = dynamicCommands;
+  if (!command) {
+    return;
+  }
+  return createCommandMapping(operation, command, "dynamic", `Activity ${operation.activityType} was dispatched dynamically; the static call site cannot name it.`, "dynamic-dispatch", `Runtime Activity ${operation.activityType} attributed to dynamic dispatch site ${command.name}.`);
+}
+
+// packages/mapper/src/mappings.ts
+function getEventIds2(operation) {
+  return operation.eventReferences.map((reference) => reference.eventId);
+}
+function getCommandsOfKind(workflow, kind) {
+  return workflow.temporalCommands.filter((command) => command.kind === kind).toSorted((left, right) => left.staticOrder - right.staticOrder);
+}
+function createWorkflowMapping(operation, workflow, trace) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: workflow.id,
+    confidence: "exact",
+    reason: `Workflow lifecycle event belongs to ${trace.execution.workflowType}.`,
+    evidence: [
+      {
+        kind: "workflow-type",
+        description: `Runtime Workflow type ${trace.execution.workflowType} matched static Workflow ${workflow.name}.`,
+        eventIds: getEventIds2(operation),
+        staticNodeId: workflow.id
+      },
+      {
+        kind: "source-location",
+        description: `Static Workflow source is ${workflow.source.path}:${workflow.source.start.line}.`,
+        staticNodeId: workflow.id
+      }
+    ]
+  };
+}
+function createActivityMapping(operation, command, occurrence) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: command.id,
+    confidence: "exact",
+    reason: `Activity ${operation.activityType} matched by Activity type and command order.`,
+    evidence: [
+      {
+        kind: "activity-type",
+        description: `Runtime Activity type ${operation.activityType} matched static Activity command ${command.name}.`,
+        eventIds: getEventIds2(operation),
+        staticNodeId: command.id
+      },
+      {
+        kind: "command-order",
+        description: `Runtime Activity occurrence ${occurrence + 1} matched static command order ${command.staticOrder}.`,
+        eventIds: getEventIds2(operation),
+        staticNodeId: command.id
+      },
+      {
+        kind: "source-location",
+        description: `Static Activity source is ${command.source.path}:${command.source.start.line}.`,
+        staticNodeId: command.id
+      }
+    ]
+  };
+}
+function createSignalMapping(operation, signal) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: signal.id,
+    confidence: "exact",
+    reason: `Signal ${operation.signalName} matched a static Signal definition by name.`,
+    evidence: [
+      {
+        kind: "signal-name",
+        description: `Runtime Signal ${operation.signalName} matched static Signal ${signal.name}.`,
+        eventIds: getEventIds2(operation),
+        staticNodeId: signal.id
+      },
+      {
+        kind: "source-location",
+        description: `Static Signal source is ${signal.source.path}:${signal.source.start.line}.`,
+        staticNodeId: signal.id
+      }
+    ]
+  };
+}
+function createTimerMapping(operation, command, occurrence, confidence) {
+  return {
+    runtimeOperationId: operation.id,
+    staticNodeId: command.id,
+    confidence,
+    reason: confidence === "exact" ? "The only runtime timer matched the only static timer." : `Runtime timer occurrence ${occurrence + 1} matched static timer order ${command.staticOrder}.`,
+    evidence: [
+      {
+        kind: "timer-order",
+        description: `Runtime timer ${operation.timerId} matched static timer command ${command.id} by start order.`,
+        eventIds: getEventIds2(operation),
+        staticNodeId: command.id
+      },
+      {
+        kind: "source-location",
+        description: `Static timer source is ${command.source.path}:${command.source.start.line}.`,
+        staticNodeId: command.id
+      }
+    ]
+  };
+}
+function mapActivityOperation(operation, activityCommands, dynamicCommands, occurrences) {
+  const occurrence = occurrences.get(operation.activityType) ?? 0;
+  occurrences.set(operation.activityType, occurrence + 1);
+  const command = activityCommands.filter((candidate) => candidate.name === operation.activityType)[occurrence];
+  if (command) {
+    return createActivityMapping(operation, command, occurrence);
+  }
+  return mapDynamicActivityFallback(operation, dynamicCommands) ?? createUnmappedMapping(operation, `No static Activity command matched ${operation.activityType} occurrence ${occurrence + 1}.`);
+}
+function mapSignalOperation(operation, signals) {
+  const signal = signals.find((candidate) => candidate.name === operation.signalName);
+  return signal ? createSignalMapping(operation, signal) : createUnmappedMapping(operation, `No static Signal definition matched ${operation.signalName}.`);
+}
+function mapTimerOperation(operation, timerCommands, occurrence, runtimeTimerCount) {
+  const command = timerCommands[occurrence];
+  if (!command) {
+    return createUnmappedMapping(operation, `No static timer command matched runtime timer occurrence ${occurrence + 1}.`);
+  }
+  const confidence = timerCommands.length === 1 && runtimeTimerCount === 1 ? "exact" : "inferred";
+  return createTimerMapping(operation, command, occurrence, confidence);
+}
+function mapCoreOperation(operation, context) {
+  switch (operation.kind) {
+    case "workflow-lifecycle":
+      return createWorkflowMapping(operation, context.workflow, context.trace);
+    case "activity":
+      return mapActivityOperation(operation, context.activityCommands, context.dynamicCommands, context.activityOccurrences);
+    case "signal":
+      return mapSignalOperation(operation, context.workflow.messageSurface.signals);
+    case "timer": {
+      const mapping = mapTimerOperation(operation, context.timerCommands, context.timerOccurrence, context.runtimeTimerCount);
+      context.timerOccurrence += 1;
+      return mapping;
+    }
+    default:
+      return;
+  }
+}
+function mapExtendedOperation(operation, context) {
+  switch (operation.kind) {
+    case "update":
+      return mapUpdateOperation(operation, context.workflow.messageSurface.updates);
+    case "child-workflow":
+      return mapChildWorkflowOperation(operation, context.childCommands, context.childOccurrences);
+    case "external-signal":
+      return mapExternalSignalOperation(operation, context.externalCommands, context.externalOccurrences);
+    case "marker":
+      return mapMarkerOperation(operation, context.patchCommands);
+    case "continue-as-new":
+      return mapContinueAsNewOperation(operation, context.continueAsNewCommands);
+    case "cancel-request":
+      return mapCancelRequestOperation(operation, context.workflow);
+    default:
+      return createUnmappedMapping(operation, `Runtime operation ${operation.id} is not supported yet.`);
+  }
+}
+function mapOperation(operation, context) {
+  return mapCoreOperation(operation, context) ?? mapExtendedOperation(operation, context);
+}
+function createMappings(workflow, trace) {
+  const context = {
+    workflow,
+    trace,
+    activityCommands: getCommandsOfKind(workflow, "activity"),
+    timerCommands: getCommandsOfKind(workflow, "timer"),
+    dynamicCommands: getCommandsOfKind(workflow, "dynamic"),
+    childCommands: getCommandsOfKind(workflow, "child-workflow"),
+    externalCommands: getCommandsOfKind(workflow, "external-workflow"),
+    patchCommands: getCommandsOfKind(workflow, "patch"),
+    continueAsNewCommands: getCommandsOfKind(workflow, "continue-as-new"),
+    activityOccurrences: new Map,
+    childOccurrences: new Map,
+    externalOccurrences: new Map,
+    runtimeTimerCount: trace.operations.filter((operation) => operation.kind === "timer").length,
+    timerOccurrence: 0
+  };
+  return trace.operations.map((operation) => mapOperation(operation, context));
+}
+
+// packages/mapper/src/coverage.ts
+var commandNodeKinds = [
+  "activity",
+  "timer",
+  "condition",
+  "child-workflow",
+  "external-workflow",
+  "continue-as-new",
+  "patch",
+  "cancellation-scope",
+  "dynamic"
+];
+var messageNodeKinds = [
+  { surface: "signals", kind: "signal" },
+  { surface: "queries", kind: "query" },
+  { surface: "updates", kind: "update" }
+];
+function markObservedScopes(nodes) {
+  const observedSources = nodes.filter((node) => node.observed && node.kind !== "cancellation-scope" && node.source).map((node) => node.source);
+  for (const node of nodes) {
+    if (node.kind !== "cancellation-scope" || node.observed || !node.source) {
+      continue;
+    }
+    const scope = node.source;
+    node.observed = observedSources.some((candidate) => candidate !== undefined && candidate.path === scope.path && candidate.start.offset >= scope.start.offset && candidate.end.offset <= scope.end.offset);
+  }
+}
+function createStaticNodes(workflow, mappings) {
+  const observed = new Set(mappings.flatMap((mapping) => mapping.staticNodeId ?? []));
+  const nodes = [
+    {
+      id: workflow.id,
+      kind: "workflow",
+      name: workflow.name,
+      observed: observed.has(workflow.id),
+      source: workflow.source
+    }
+  ];
+  for (const kind of commandNodeKinds) {
+    for (const command of getCommandsOfKind(workflow, kind)) {
+      nodes.push({
+        id: command.id,
+        kind,
+        name: command.name,
+        observed: observed.has(command.id),
+        source: command.source
+      });
+    }
+  }
+  for (const { surface, kind } of messageNodeKinds) {
+    for (const message of workflow.messageSurface[surface]) {
+      nodes.push({
+        id: message.id,
+        kind,
+        name: message.name,
+        observed: observed.has(message.id),
+        source: message.source
+      });
+    }
+  }
+  markObservedScopes(nodes);
+  return nodes;
+}
+function createDiagnostics(mappings) {
+  return mappings.filter((mapping) => !mapping.staticNodeId).map((mapping) => ({
+    code: "TEM_UNMAPPED_RUNTIME_OPERATION",
+    category: "mapping",
+    severity: "warning",
+    message: mapping.reason,
+    confidence: mapping.confidence
+  }));
+}
+function isActivityOperation(operation) {
+  return operation.kind === "activity";
+}
+function createMessageCoverage(workflow, trace) {
+  const receivedSignals = [
+    ...new Set(trace.operations.filter((operation) => operation.kind === "signal").map((operation) => operation.signalName))
+  ].toSorted((left, right) => left.localeCompare(right));
+  const receivedUpdates = [
+    ...new Set(trace.operations.filter((operation) => operation.kind === "update").map((operation) => operation.updateName))
+  ].toSorted((left, right) => left.localeCompare(right));
+  return {
+    staticSignals: workflow.messageSurface.signals.length,
+    receivedSignals,
+    staticUpdates: workflow.messageSurface.updates.length,
+    receivedUpdates,
+    staticQueries: workflow.messageSurface.queries.length
+  };
+}
+function createTimerCoverage(workflow, trace) {
+  const timerOperations = trace.operations.filter((operation) => operation.kind === "timer");
+  return {
+    staticTotal: getCommandsOfKind(workflow, "timer").length,
+    fired: timerOperations.filter((operation) => operation.status === "fired").length,
+    canceled: timerOperations.filter((operation) => operation.status === "canceled").length,
+    pending: timerOperations.filter((operation) => operation.status === "pending").length
+  };
+}
+function createCoverage(workflow, staticNodes, mappings, trace) {
+  const activityOperations = trace.operations.filter(isActivityOperation);
+  const observedActivityIds = new Set(staticNodes.filter((node) => node.kind === "activity" && node.observed).map((node) => node.id));
+  return {
+    nodes: {
+      total: staticNodes.length,
+      observed: staticNodes.filter((node) => node.observed).length,
+      skipped: staticNodes.filter((node) => !node.observed).length,
+      unmappedRuntimeOperations: mappings.filter((mapping) => !mapping.staticNodeId).length
+    },
+    activities: {
+      staticTotal: staticNodes.filter((node) => node.kind === "activity").length,
+      observed: observedActivityIds.size,
+      retried: activityOperations.filter((operation) => operation.attempts.length > 1 || operation.attempts.some((attempt) => attempt.attempt > 1)).length,
+      failed: activityOperations.filter((operation) => operation.status !== "completed").length
+    },
+    messages: createMessageCoverage(workflow, trace),
+    timers: createTimerCoverage(workflow, trace)
+  };
+}
+
+// packages/mapper/src/aggregate.ts
+function countBy(values) {
+  const counts = {};
+  for (const value of values) {
+    counts[value] = (counts[value] ?? 0) + 1;
+  }
+  return Object.fromEntries(Object.entries(counts).toSorted(([left], [right]) => left.localeCompare(right)));
+}
+function aggregateActivities(traces) {
+  const stats = new Map;
+  for (const trace of traces) {
+    for (const operation of trace.operations) {
+      if (operation.kind !== "activity") {
+        continue;
+      }
+      const entry = stats.get(operation.activityType) ?? {
+        activityType: operation.activityType,
+        executions: 0,
+        retried: 0,
+        failed: 0
+      };
+      entry.executions += 1;
+      if (operation.attempts.length > 1 || operation.attempts.some((attempt) => attempt.attempt > 1)) {
+        entry.retried += 1;
+      }
+      if (operation.status !== "completed") {
+        entry.failed += 1;
+      }
+      stats.set(operation.activityType, entry);
+    }
+  }
+  return [...stats.values()].toSorted((left, right) => right.retried - left.retried || right.failed - left.failed || left.activityType.localeCompare(right.activityType));
+}
+function aggregateNodes(overlays) {
+  const nodes = new Map;
+  for (const overlay of overlays) {
+    for (const node of overlay.staticNodes) {
+      const entry = nodes.get(node.id) ?? {
+        nodeId: node.id,
+        kind: node.kind,
+        name: node.name,
+        observedRuns: 0,
+        totalRuns: 0
+      };
+      entry.totalRuns += 1;
+      if (node.observed) {
+        entry.observedRuns += 1;
+      }
+      nodes.set(node.id, entry);
+    }
+  }
+  return [...nodes.values()].toSorted((left, right) => left.nodeId.localeCompare(right.nodeId));
+}
+function aggregateTimers(traces) {
+  const timers = { fired: 0, canceled: 0, pending: 0 };
+  for (const trace of traces) {
+    for (const operation of trace.operations) {
+      if (operation.kind === "timer") {
+        timers[operation.status] += 1;
+      }
+    }
+  }
+  return timers;
+}
+function createAggregateReport(options) {
+  const traces = options.traces.filter((trace) => trace.execution.workflowType === options.workflowType);
+  const overlays = options.overlays.filter((overlay) => overlay.workflow === options.workflowType);
+  if (traces.length === 0) {
+    throw new Error(`No trace artifacts matched Workflow type "${options.workflowType}".`);
+  }
+  const nodes = aggregateNodes(overlays);
+  return {
+    workflowType: options.workflowType,
+    runs: traces.length,
+    statuses: countBy(traces.map((trace) => trace.execution.status)),
+    activities: aggregateActivities(traces),
+    signals: countBy(traces.flatMap((trace) => trace.operations.flatMap((operation) => operation.kind === "signal" ? [operation.signalName] : []))),
+    updates: countBy(traces.flatMap((trace) => trace.operations.flatMap((operation) => operation.kind === "update" ? [operation.updateName] : []))),
+    timers: aggregateTimers(traces),
+    hotPathNodes: nodes.filter((node) => node.totalRuns > 0 && node.observedRuns === node.totalRuns),
+    rareBranchNodes: nodes.filter((node) => node.observedRuns > 0 && node.observedRuns * 2 <= node.totalRuns),
+    nodes
+  };
+}
+function formatAggregateReport(report) {
+  const lines = [
+    `Aggregate Report: ${report.workflowType}`,
+    "",
+    `Runs: ${report.runs}`,
+    `Statuses: ${Object.entries(report.statuses).map(([status, count]) => `${status}=${count}`).join(", ")}`,
+    "",
+    "Activities (by retries, failures)"
+  ];
+  for (const activity of report.activities) {
+    lines.push(`  ${activity.activityType}: ${activity.executions} execution(s), ${activity.retried} retried, ${activity.failed} failed`);
+  }
+  if (Object.keys(report.signals).length > 0) {
+    lines.push("", "Signals received");
+    for (const [name, count] of Object.entries(report.signals)) {
+      lines.push(`  ${name}: ${count}`);
+    }
+  }
+  if (Object.keys(report.updates).length > 0) {
+    lines.push("", "Updates received");
+    for (const [name, count] of Object.entries(report.updates)) {
+      lines.push(`  ${name}: ${count}`);
+    }
+  }
+  lines.push("", `Timers: ${report.timers.fired} fired, ${report.timers.canceled} canceled, ${report.timers.pending} pending`);
+  lines.push("", "Path coverage");
+  for (const node of report.nodes) {
+    lines.push(`  ${node.kind} ${node.name}: observed in ${node.observedRuns}/${node.totalRuns} run(s)`);
+  }
+  if (report.rareBranchNodes.length > 0) {
+    lines.push("", "Rare branches (observed in at most half of runs)");
+    for (const node of report.rareBranchNodes) {
+      lines.push(`  ${node.kind} ${node.name}: ${node.observedRuns}/${node.totalRuns}`);
+    }
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+
+// packages/mapper/src/index.ts
+function getWorkflow(analysis, workflowName) {
+  const workflow = analysis.workflows.find((candidate) => candidate.name === workflowName);
+  if (!workflow) {
+    throw new Error(`Workflow "${workflowName}" was not found in static analysis.`);
+  }
+  return workflow;
+}
+function applyReplayEvidence(mappings, trace, replayCapture) {
+  const capturedActivities = replayCapture.filter((command) => command.kind === "activity").toSorted((left, right) => left.sequence - right.sequence);
+  const activityOperations = trace.operations.filter((operation) => operation.kind === "activity").toSorted((left, right) => (left.eventReferences[0]?.eventId ?? 0) - (right.eventReferences[0]?.eventId ?? 0));
+  activityOperations.forEach((operation, index) => {
+    const captured = capturedActivities[index];
+    if (!captured || operation.kind !== "activity" || captured.name !== operation.activityType) {
+      return;
+    }
+    const mapping = mappings.find((entry) => entry.runtimeOperationId === operation.id);
+    if (mapping?.confidence === "dynamic") {
+      mapping.confidence = "inferred";
+      mapping.reason = `${mapping.reason} Replay confirmed ${captured.name} at command sequence ${captured.sequence}.`;
+      mapping.evidence.push({
+        kind: "replay-command-sequence",
+        description: `Replay observed Activity ${captured.name} scheduled at command sequence ${captured.sequence}.`,
+        staticNodeId: mapping.staticNodeId ?? undefined
+      });
+    }
+  });
+}
+function createExecutionOverlay(options) {
+  const workflow = getWorkflow(options.analysis, options.workflowName);
+  const mappings = createMappings(workflow, options.trace);
+  if (options.replayCapture) {
+    applyReplayEvidence(mappings, options.trace, options.replayCapture);
+  }
+  const staticNodes = createStaticNodes(workflow, mappings);
+  return {
+    schemaVersion: "temporal-overlay/v1",
+    artifactId: `overlay:${options.workflowName}:${options.trace.artifactId}`,
+    staticAnalysisId: options.analysis.artifactId,
+    runtimeTraceId: options.trace.artifactId,
+    workflow: options.workflowName,
+    staticNodes,
+    mappings,
+    branchOutcomes: [],
+    coverage: createCoverage(workflow, staticNodes, mappings, options.trace),
+    diagnostics: createDiagnostics(mappings)
+  };
+}
+function formatSource(node) {
+  return node.source ? `${node.source.path}:${node.source.start.line}` : "unknown source";
+}
+function getMappingForNode(overlay, node) {
+  return overlay.mappings.find((mapping) => mapping.staticNodeId === node.id);
+}
+function appendNodeSection(lines, overlay, kind, heading) {
+  const nodes = overlay.staticNodes.filter((candidate) => candidate.kind === kind);
+  if (nodes.length === 0) {
+    return;
+  }
+  lines.push("", heading);
+  for (const node of nodes) {
+    const mapping = getMappingForNode(overlay, node);
+    const state = node.observed ? "observed" : "not observed";
+    const confidence = mapping?.confidence ?? "unknown";
+    lines.push(`  ${node.name} (${state}) -> ${formatSource(node)} [${confidence}]`);
+    if (mapping) {
+      lines.push(`    ${mapping.reason}`);
+    }
+  }
+}
+function createOverlayReport(overlay) {
+  const lines = [
+    `Trace Report: ${overlay.workflow}`,
+    "",
+    `Mapped runtime operations: ${overlay.mappings.length - overlay.coverage.nodes.unmappedRuntimeOperations}/${overlay.mappings.length}`,
+    `Unmapped runtime operations: ${overlay.coverage.nodes.unmappedRuntimeOperations}`,
+    "",
+    "Executed Activities"
+  ];
+  for (const node of overlay.staticNodes.filter((candidate) => candidate.kind === "activity")) {
+    const mapping = getMappingForNode(overlay, node);
+    const state = node.observed ? "observed" : "not observed";
+    const confidence = mapping?.confidence ?? "unknown";
+    lines.push(`  ${node.name} (${state}) -> ${formatSource(node)} [${confidence}]`);
+    if (mapping) {
+      lines.push(`    ${mapping.reason}`);
+    }
+  }
+  appendNodeSection(lines, overlay, "signal", "Signals");
+  appendNodeSection(lines, overlay, "timer", "Timers");
+  appendNodeSection(lines, overlay, "condition", "Conditions");
+  return `${lines.join(`
+`)}
+`;
+}
+
+// packages/renderers/src/shared.ts
+function getWorkflow2(analysis, workflowName) {
+  const workflow = analysis.workflows.find((candidate) => candidate.name === workflowName);
+  if (!workflow) {
+    throw new Error(`Workflow "${workflowName}" was not found.`);
+  }
+  return workflow;
+}
+function sortWorkflows(workflows) {
+  return workflows.toSorted((left, right) => left.name.localeCompare(right.name));
+}
+function getCommandsOfKind2(workflow, kind) {
+  return workflow.temporalCommands.filter((command) => command.kind === kind).toSorted((left, right) => left.staticOrder - right.staticOrder);
+}
+function formatSource2(value) {
+  return `${value.source.path}:${value.source.start.line}`;
+}
+function getOverlayForWorkflow(workflow, overlays) {
+  return overlays.find((overlay) => overlay.workflow === workflow.name);
+}
+function isObserved(nodeId, overlay) {
+  return Boolean(overlay?.staticNodes.some((node) => node.id === nodeId && node.observed));
+}
+function getMappingConfidence(nodeId, overlay) {
+  return overlay?.mappings.find((mapping) => mapping.staticNodeId === nodeId)?.confidence ?? "unknown";
+}
+function formatWorkflowSignature(workflow) {
+  const args = workflow.signature.args.map((arg) => `${arg.displayName ?? "arg"}: ${arg.display}`).join(", ");
+  return `${workflow.name}(${args}): ${workflow.signature.result.display}`;
+}
+function createAlignedMarkdownTable(headers, alignments, rows) {
+  const tableRows = [headers, ...rows];
+  const widths = headers.map((_, columnIndex) => Math.max(...tableRows.map((row) => row[columnIndex]?.length ?? 0)));
+  const separator = widths.map((width, columnIndex) => {
+    const dashCount = Math.max(width - (alignments[columnIndex] === "right" ? 1 : 0), 3);
+    return alignments[columnIndex] === "right" ? `${"-".repeat(dashCount)}:` : "-".repeat(dashCount);
+  });
+  return [
+    formatAlignedTableRow(headers, widths, alignments),
+    formatAlignedTableRow(separator, widths, alignments),
+    ...rows.map((row) => formatAlignedTableRow(row, widths, alignments))
+  ];
+}
+function formatAlignedTableRow(cells, widths, alignments) {
+  return `| ${cells.map((cell, index) => alignments[index] === "right" ? cell.padStart(widths[index] ?? 0) : cell.padEnd(widths[index] ?? 0)).join(" | ")} |`;
+}
+
+// packages/renderers/src/markdown.ts
+function renderWorkflowIndexMarkdown(options) {
+  const lines = ["# Temporal Workflow Explorer", "", "## Workflows", ""];
+  for (const workflow of sortWorkflows(options.analysis.workflows)) {
+    lines.push(`- [${workflow.name}](./${workflow.name}.md) - \`${formatSource2(workflow)}\``);
+  }
+  lines.push("", "## Artifacts", "");
+  lines.push(`- Static analysis: \`${options.analysis.artifactId}\``);
+  for (const trace of options.traces ?? []) {
+    lines.push(`- Runtime trace: \`${trace.artifactId}\` (${trace.execution.status})`);
+  }
+  for (const overlay of options.overlays ?? []) {
+    lines.push(`- Execution overlay: \`${overlay.artifactId}\``);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+function appendActivitiesSection(lines, workflow, overlay) {
+  const commands = getCommandsOfKind2(workflow, "activity");
+  lines.push("## Activities", "");
+  if (commands.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  lines.push(...createAlignedMarkdownTable(["Order", "Activity", "Source", "Observed", "Confidence"], ["right", "left", "left", "left", "left"], commands.map((command) => [
+    String(command.staticOrder + 1),
+    `\`${command.name}\``,
+    `\`${formatSource2(command)}\``,
+    isObserved(command.id, overlay) ? "yes" : "no",
+    getMappingConfidence(command.id, overlay)
+  ])));
+}
+function collectMessageRows(workflow, overlay) {
+  const formatPayload = (args) => args.map((arg) => `\`${arg.display}\``).join(", ") || "none";
+  return [
+    ...workflow.messageSurface.signals.map((signal) => ({
+      kind: "Signal",
+      id: signal.id,
+      name: signal.name,
+      payload: formatPayload(signal.args),
+      source: formatSource2(signal),
+      received: isObserved(signal.id, overlay) ? "yes" : "no"
+    })),
+    ...workflow.messageSurface.queries.map((query) => ({
+      kind: "Query",
+      id: query.id,
+      name: query.name,
+      payload: formatPayload(query.args),
+      source: formatSource2(query),
+      received: "not recorded"
+    })),
+    ...workflow.messageSurface.updates.map((update) => ({
+      kind: "Update",
+      id: update.id,
+      name: update.name,
+      payload: formatPayload(update.args),
+      source: formatSource2(update),
+      received: isObserved(update.id, overlay) ? "yes" : "no"
+    }))
+  ];
+}
+function appendMessagesSection(lines, workflow, overlay) {
+  lines.push("", "## Messages", "");
+  const rows = collectMessageRows(workflow, overlay);
+  if (rows.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  lines.push(...createAlignedMarkdownTable(["Kind", "Name", "Payload", "Source", "Received", "Confidence"], ["left", "left", "left", "left", "left", "left"], rows.map((row) => [
+    row.kind,
+    `\`${row.name}\``,
+    row.payload,
+    `\`${row.source}\``,
+    row.received,
+    row.kind === "Query" ? "exact" : getMappingConfidence(row.id, overlay)
+  ])));
+  if (workflow.messageSurface.queries.length > 0) {
+    lines.push("", "Queries are served from Workflow state and do not normally add events to Event History.");
+  }
+}
+var operationCommandKinds = [
+  "child-workflow",
+  "external-workflow",
+  "continue-as-new",
+  "patch",
+  "cancellation-scope",
+  "dynamic"
+];
+function appendOperationsSection(lines, workflow, overlay) {
+  const operations = operationCommandKinds.flatMap((kind) => getCommandsOfKind2(workflow, kind)).toSorted((left, right) => left.staticOrder - right.staticOrder);
+  lines.push("", "## Temporal Operations", "");
+  if (operations.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  lines.push(...createAlignedMarkdownTable(["Order", "Kind", "Target", "Source", "Observed", "Confidence"], ["right", "left", "left", "left", "left", "left"], operations.map((command) => [
+    String(command.staticOrder + 1),
+    command.kind,
+    `\`${command.name}\``,
+    `\`${formatSource2(command)}\``,
+    isObserved(command.id, overlay) ? "yes" : "no",
+    getMappingConfidence(command.id, overlay)
+  ])));
+}
+function appendWaitsSection(lines, workflow, overlay) {
+  lines.push("", "## Waits", "");
+  const waits = [
+    ...getCommandsOfKind2(workflow, "condition"),
+    ...getCommandsOfKind2(workflow, "timer")
+  ].toSorted((left, right) => left.staticOrder - right.staticOrder);
+  if (waits.length === 0) {
+    lines.push("- none");
+    return;
+  }
+  lines.push(...createAlignedMarkdownTable(["Order", "Kind", "Expression", "Source", "Observed", "Confidence"], ["right", "left", "left", "left", "left", "left"], waits.map((command) => [
+    String(command.staticOrder + 1),
+    command.kind,
+    `\`${command.name}\``,
+    `\`${formatSource2(command)}\``,
+    isObserved(command.id, overlay) ? "yes" : "no",
+    getMappingConfidence(command.id, overlay)
+  ])));
+}
+function appendRuntimeSummary(lines, overlay) {
+  lines.push("", "## Runtime Summary", "");
+  if (!overlay) {
+    lines.push("- No runtime overlay artifact was provided.");
+    return;
+  }
+  lines.push(`- Mapped runtime operations: ${overlay.mappings.length - overlay.coverage.nodes.unmappedRuntimeOperations}/${overlay.mappings.length}`);
+  lines.push(`- Unmapped runtime operations: ${overlay.coverage.nodes.unmappedRuntimeOperations}`);
+  if (overlay.coverage.messages.receivedSignals.length > 0) {
+    lines.push(`- Received Signals: ${overlay.coverage.messages.receivedSignals.join(", ")}`);
+  }
+  if (overlay.coverage.timers.staticTotal > 0) {
+    lines.push(`- Timers: ${overlay.coverage.timers.fired} fired, ${overlay.coverage.timers.canceled} canceled, ${overlay.coverage.timers.pending} pending`);
+  }
+  lines.push("- Payload previews: redacted by default");
+}
+function renderWorkflowMarkdown(options) {
+  const workflow = getWorkflow2(options.analysis, options.workflowName);
+  const overlay = getOverlayForWorkflow(workflow, options.overlays ?? []);
+  const lines = [
+    `# ${workflow.name}`,
+    "",
+    `Source: \`${formatSource2(workflow)}\``,
+    "",
+    `Signature: \`${formatWorkflowSignature(workflow)}\``,
+    ""
+  ];
+  appendActivitiesSection(lines, workflow, overlay);
+  appendMessagesSection(lines, workflow, overlay);
+  appendWaitsSection(lines, workflow, overlay);
+  appendOperationsSection(lines, workflow, overlay);
+  appendRuntimeSummary(lines, overlay);
+  lines.push("", "## Warnings", "");
+  if (workflow.diagnostics.length === 0) {
+    lines.push("- none");
+  }
+  for (const diagnostic of workflow.diagnostics) {
+    lines.push(`- ${diagnostic.severity}: ${diagnostic.message}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+
+// packages/renderers/src/mermaid.ts
+function toMermaidId(value) {
+  return value.replaceAll(/[^A-Za-z0-9_]/g, "_");
+}
+function toMermaidLabel(value) {
+  return value.replaceAll('"', "'");
+}
+var flowCommandKinds = new Set([
+  "activity",
+  "timer",
+  "condition",
+  "child-workflow",
+  "external-workflow",
+  "continue-as-new",
+  "patch",
+  "dynamic"
+]);
+function renderCommandNode(command) {
+  const id = toMermaidId(command.id);
+  const label = toMermaidLabel(command.name);
+  if (command.kind === "condition" || command.kind === "patch") {
+    return `  ${id}{"${label}"}`;
+  }
+  if (command.kind === "timer") {
+    return `  ${id}(("${label}"))`;
+  }
+  if (command.kind === "child-workflow" || command.kind === "external-workflow") {
+    return `  ${id}[["${label}"]]`;
+  }
+  if (command.kind === "dynamic") {
+    return `  ${id}[/"${label}"/]`;
+  }
+  return `  ${id}["${label}"]`;
+}
+function renderWorkflowMermaid(analysis, workflowName) {
+  const workflow = getWorkflow2(analysis, workflowName);
+  const commands = workflow.temporalCommands.filter((command) => flowCommandKinds.has(command.kind)).toSorted((left, right) => left.staticOrder - right.staticOrder);
+  const lines = ["flowchart TD", `  start(["${workflow.name}"])`];
+  for (const command of commands) {
+    lines.push(renderCommandNode(command));
+  }
+  lines.push('  complete(["complete"])');
+  const nodeIds = ["start", ...commands.map((command) => toMermaidId(command.id)), "complete"];
+  for (let index = 0;index < nodeIds.length - 1; index += 1) {
+    lines.push(`  ${nodeIds[index]} --> ${nodeIds[index + 1]}`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+
+// packages/renderers/src/declarations.ts
+import { dirname as dirname2, relative as relative3 } from "path";
+var declarationsDirectory = ".temporal-explorer/workflows";
+function toImportSpecifier(module) {
+  const specifier = relative3(dirname2(`${declarationsDirectory}/placeholder.d.ts`), module).split("\\").join("/");
+  return specifier.startsWith(".") ? specifier : `./${specifier}`;
+}
+function renderImports(workflow) {
+  const byModule = new Map;
+  for (const dependency of workflow.dependencies) {
+    const names = byModule.get(dependency.module) ?? [];
+    names.push(dependency.name);
+    byModule.set(dependency.module, names);
+  }
+  return [...byModule.entries()].toSorted(([left], [right]) => left.localeCompare(right)).map(([module, names]) => `import type { ${names.toSorted((a, b) => a.localeCompare(b)).join(", ")} } from '${toImportSpecifier(module)}';`);
+}
+function knownTypeNames(workflow) {
+  return new Set(workflow.dependencies.map((dependency) => dependency.name));
+}
+function renderTypeText(display, known) {
+  return display.replaceAll(/\b[A-Z][A-Za-z0-9_]*\b/gu, (name) => {
+    if (known.has(name) || structuralTypeNames.has(name)) {
+      return name;
+    }
+    return "unknown";
+  });
+}
+var structuralTypeNames = new Set([
+  "Promise",
+  "Array",
+  "Record",
+  "Map",
+  "Set",
+  "Date",
+  "Partial",
+  "Readonly",
+  "Pick",
+  "Omit"
+]);
+function renderSignatureLines(workflow, known) {
+  const parameters = workflow.signature.args.map((arg, index) => `${arg.displayName ?? `arg${index}`}: ${renderTypeText(arg.display, known)}`).join(", ");
+  const result = renderTypeText(workflow.signature.result.display, known);
+  const resultType = result.startsWith("Promise<") ? result : `Promise<${result}>`;
+  return [
+    `/** Source: ${workflow.source.path}:${workflow.source.start.line} [confidence: exact] */`,
+    `export declare function ${workflow.name}(${parameters}): ${resultType};`
+  ];
+}
+function renderMessageLines(workflow, known) {
+  const lines = [];
+  for (const signal of workflow.messageSurface.signals) {
+    const args = signal.args.map((arg) => renderTypeText(arg.display, known)).join(", ");
+    lines.push(`/** Source: ${signal.source.path}:${signal.source.start.line} [confidence: ${signal.confidence}] */`, `export declare const ${signal.name}Signal: import('@temporalio/workflow').SignalDefinition<[${args}]>;`);
+  }
+  for (const query of workflow.messageSurface.queries) {
+    const args = query.args.map((arg) => renderTypeText(arg.display, known)).join(", ");
+    const result = query.result ? renderTypeText(query.result.display, known) : "unknown";
+    lines.push(`/** Source: ${query.source.path}:${query.source.start.line} [confidence: ${query.confidence}] */`, `export declare const ${query.name}Query: import('@temporalio/workflow').QueryDefinition<${result}, [${args}]>;`);
+  }
+  for (const update of workflow.messageSurface.updates) {
+    const args = update.args.map((arg) => renderTypeText(arg.display, known)).join(", ");
+    const result = update.result ? renderTypeText(update.result.display, known) : "unknown";
+    lines.push(`/** Source: ${update.source.path}:${update.source.start.line} [confidence: ${update.confidence}] */`, `export declare const ${update.name}Update: import('@temporalio/workflow').UpdateDefinition<${result}, [${args}]>;`);
+  }
+  return lines;
+}
+function renderActivityLines(analysis, workflow) {
+  const activityCommands = workflow.temporalCommands.filter((command) => command.kind === "activity");
+  if (activityCommands.length === 0) {
+    return [];
+  }
+  const names = [...new Set(activityCommands.map((command) => command.name))].toSorted((a, b) => a.localeCompare(b));
+  const lines = ["/** Activity names referenced by this Workflow. */"];
+  lines.push(`export type ${capitalize(workflow.name)}ActivityName = ${names.map((name) => `'${name}'`).join(" | ")};`);
+  for (const name of names) {
+    const activity = analysis.activities.find((candidate) => candidate.name === name);
+    if (activity?.implementationSource) {
+      lines.push(`/** Implementation: ${activity.implementationSource.path}:${activity.implementationSource.start.line} [confidence: ${activity.confidence}] */`);
+    } else {
+      lines.push(`/** Implementation unresolved [confidence: ${activity?.confidence ?? "unknown"}] */`);
+    }
+  }
+  return lines;
+}
+function capitalize(value) {
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function renderWorkflowDeclaration(analysis, workflowName) {
+  const workflow = getWorkflow2(analysis, workflowName);
+  const known = knownTypeNames(workflow);
+  const sections = [
+    ["// Generated by Temporal Workflow Explorer. Do not edit."],
+    renderImports(workflow),
+    renderSignatureLines(workflow, known),
+    renderMessageLines(workflow, known),
+    renderActivityLines(analysis, workflow)
+  ].filter((section) => section.length > 0);
+  return `${sections.map((section) => section.join(`
+`)).join(`
+
+`)}
+`;
+}
+
+// packages/renderers/src/index.ts
+function createDocumentationSet(options) {
+  const files = [
+    {
+      path: "index.md",
+      contents: renderWorkflowIndexMarkdown(options)
+    }
+  ];
+  for (const workflow of sortWorkflows(options.analysis.workflows)) {
+    files.push({
+      path: `${workflow.name}.md`,
+      contents: renderWorkflowMarkdown({ ...options, workflowName: workflow.name })
+    });
+    files.push({
+      path: `${workflow.name}.mmd`,
+      contents: renderWorkflowMermaid(options.analysis, workflow.name)
+    });
+  }
+  return files.toSorted((left, right) => left.path.localeCompare(right.path));
+}
+
+// packages/schemas/src/temporal-analysis.ts
+import { z as z2 } from "zod";
+
+// packages/schemas/src/common.ts
+import { z } from "zod";
+var confidenceSchema = z.union([
+  z.literal("exact"),
+  z.literal("inferred"),
+  z.literal("partial"),
+  z.literal("ambiguous"),
+  z.literal("dynamic"),
+  z.literal("unknown")
+]);
+var sourcePositionSchema = z.object({
+  line: z.number().int().positive(),
+  column: z.number().int().positive(),
+  offset: z.number().int().nonnegative()
+}).strict();
+var sourceLocationSchema = z.object({
+  path: z.string().min(1),
+  pathKind: z.union([z.literal("project-relative"), z.literal("absolute")]),
+  start: sourcePositionSchema,
+  end: sourcePositionSchema,
+  symbolName: z.string().min(1).optional()
+}).strict();
+var diagnosticSchema = z.object({
+  code: z.string().min(1),
+  category: z.union([
+    z.literal("configuration"),
+    z.literal("discovery"),
+    z.literal("type-extraction"),
+    z.literal("control-flow"),
+    z.literal("determinism"),
+    z.literal("history"),
+    z.literal("mapping"),
+    z.literal("rendering"),
+    z.literal("privacy"),
+    z.literal("compatibility")
+  ]),
+  severity: z.union([z.literal("error"), z.literal("warning"), z.literal("info")]),
+  message: z.string().min(1),
+  source: sourceLocationSchema.optional(),
+  relatedSources: z.array(sourceLocationSchema).optional(),
+  confidence: confidenceSchema,
+  documentationUrl: z.string().url().optional()
+}).strict();
+var artifactMetadataSchema = z.object({
+  temporalExplorerVersion: z.string().min(1),
+  schemaVersion: z.string().min(1),
+  generatedAt: z.string().datetime().optional(),
+  inputs: z.object({
+    projectRoot: z.string(),
+    configHash: z.string(),
+    tsconfigHash: z.string().optional(),
+    packageMetadataHash: z.string().optional(),
+    lockfileHash: z.string().optional(),
+    sourceFileHashes: z.record(z.string(), z.string()),
+    temporalSdkVersions: z.record(z.string(), z.string())
+  }).strict()
+}).strict();
+
+// packages/schemas/src/temporal-analysis.ts
+var typeShapeSchema = z2.lazy(() => z2.object({
+  id: z2.string().min(1),
+  display: z2.string().min(1),
+  displayName: z2.string().min(1).optional(),
+  fullyQualifiedName: z2.string().min(1).optional(),
+  kind: z2.union([
+    z2.literal("primitive"),
+    z2.literal("object"),
+    z2.literal("array"),
+    z2.literal("tuple"),
+    z2.literal("union"),
+    z2.literal("intersection"),
+    z2.literal("literal"),
+    z2.literal("enum"),
+    z2.literal("function"),
+    z2.literal("promise"),
+    z2.literal("external"),
+    z2.literal("unknown")
+  ]),
+  nullable: z2.boolean().optional(),
+  optional: z2.boolean().optional(),
+  properties: z2.record(z2.string(), typeShapeSchema).optional(),
+  items: typeShapeSchema.optional(),
+  tupleItems: z2.array(typeShapeSchema).optional(),
+  union: z2.array(typeShapeSchema).optional(),
+  intersection: z2.array(typeShapeSchema).optional(),
+  source: sourceLocationSchema.optional(),
+  module: z2.string().min(1).optional(),
+  declaration: sourceLocationSchema.optional(),
+  typeArguments: z2.array(typeShapeSchema).optional(),
+  references: z2.array(z2.string().min(1)).optional(),
+  recursive: z2.boolean().optional(),
+  confidence: confidenceSchema
+}).strict());
+var workflowSignatureSchema = z2.object({
+  args: z2.array(typeShapeSchema),
+  result: typeShapeSchema
+}).strict();
+var temporalCommandSchema = z2.object({
+  id: z2.string().min(1),
+  kind: z2.union([
+    z2.literal("activity"),
+    z2.literal("workflow-lifecycle"),
+    z2.literal("timer"),
+    z2.literal("condition"),
+    z2.literal("signal"),
+    z2.literal("query"),
+    z2.literal("update"),
+    z2.literal("child-workflow"),
+    z2.literal("external-workflow"),
+    z2.literal("continue-as-new"),
+    z2.literal("patch"),
+    z2.literal("cancellation-scope"),
+    z2.literal("dynamic")
+  ]),
+  name: z2.string().min(1),
+  source: sourceLocationSchema,
+  confidence: confidenceSchema,
+  staticOrder: z2.number().int().nonnegative()
+}).strict();
+var signalDefinitionSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  source: sourceLocationSchema,
+  args: z2.array(typeShapeSchema),
+  handlerSource: sourceLocationSchema.optional(),
+  confidence: confidenceSchema
+}).strict();
+var queryDefinitionSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  source: sourceLocationSchema,
+  args: z2.array(typeShapeSchema),
+  result: typeShapeSchema.optional(),
+  handlerSource: sourceLocationSchema.optional(),
+  confidence: confidenceSchema
+}).strict();
+var updateDefinitionSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  source: sourceLocationSchema,
+  args: z2.array(typeShapeSchema),
+  result: typeShapeSchema.optional(),
+  handlerSource: sourceLocationSchema.optional(),
+  validatorSource: sourceLocationSchema.optional(),
+  confidence: confidenceSchema
+}).strict();
+var workflowDependencySchema = z2.object({
+  kind: z2.literal("type-import"),
+  name: z2.string().min(1),
+  module: z2.string().min(1)
+}).strict();
+var workflowDefinitionSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  source: sourceLocationSchema,
+  exported: z2.boolean(),
+  signature: workflowSignatureSchema,
+  messageSurface: z2.object({
+    signals: z2.array(signalDefinitionSchema),
+    queries: z2.array(queryDefinitionSchema),
+    updates: z2.array(updateDefinitionSchema)
+  }).strict(),
+  state: z2.object({
+    variables: z2.array(z2.unknown())
+  }).strict(),
+  body: z2.object({
+    nodes: z2.array(z2.unknown())
+  }).strict(),
+  temporalCommands: z2.array(temporalCommandSchema),
+  dependencies: z2.array(workflowDependencySchema),
+  diagnostics: z2.array(diagnosticSchema)
+}).strict();
+var activityDefinitionSchema = z2.object({
+  id: z2.string().min(1),
+  name: z2.string().min(1),
+  source: sourceLocationSchema.optional(),
+  implementationSource: sourceLocationSchema.optional(),
+  confidence: confidenceSchema
+}).strict();
+var temporalAnalysisDocumentSchema = z2.object({
+  schemaVersion: z2.literal("temporal-analysis/v1"),
+  artifactId: z2.string().min(1),
+  metadata: artifactMetadataSchema,
+  project: z2.object({
+    root: z2.string().min(1),
+    tsconfig: z2.string().min(1),
+    packageManager: z2.union([z2.literal("bun"), z2.literal("npm"), z2.literal("pnpm"), z2.literal("yarn")]).optional()
+  }).strict(),
+  sdk: z2.object({
+    temporalTypeScriptVersion: z2.string().min(1).optional(),
+    detectedPackages: z2.array(z2.string().min(1))
+  }).strict(),
+  workers: z2.array(z2.unknown()),
+  workflows: z2.array(workflowDefinitionSchema),
+  activities: z2.array(activityDefinitionSchema),
+  clients: z2.array(z2.unknown()),
+  diagnostics: z2.array(diagnosticSchema)
+}).strict();
+
+// packages/schemas/src/temporal-overlay.ts
+import { z as z3 } from "zod";
+var staticOverlayNodeSchema = z3.object({
+  id: z3.string().min(1),
+  kind: z3.union([
+    z3.literal("workflow"),
+    z3.literal("activity"),
+    z3.literal("signal"),
+    z3.literal("timer"),
+    z3.literal("condition"),
+    z3.literal("query"),
+    z3.literal("update"),
+    z3.literal("child-workflow"),
+    z3.literal("external-workflow"),
+    z3.literal("continue-as-new"),
+    z3.literal("patch"),
+    z3.literal("cancellation-scope"),
+    z3.literal("dynamic")
+  ]),
+  name: z3.string().min(1),
+  observed: z3.boolean(),
+  source: sourceLocationSchema.optional()
+}).strict();
+var mappingEvidenceSchema = z3.object({
+  kind: z3.union([
+    z3.literal("activity-type"),
+    z3.literal("command-order"),
+    z3.literal("workflow-type"),
+    z3.literal("signal-name"),
+    z3.literal("timer-order"),
+    z3.literal("update-name"),
+    z3.literal("child-workflow-type"),
+    z3.literal("external-signal-name"),
+    z3.literal("patch-id"),
+    z3.literal("continue-as-new"),
+    z3.literal("scope-containment"),
+    z3.literal("dynamic-dispatch"),
+    z3.literal("replay-command-sequence"),
+    z3.literal("event-reference"),
+    z3.literal("source-location"),
+    z3.literal("unmapped")
+  ]),
+  description: z3.string().min(1),
+  eventIds: z3.array(z3.number().int().positive()).optional(),
+  staticNodeId: z3.string().min(1).optional()
+}).strict();
+var runtimeNodeMappingSchema = z3.object({
+  runtimeOperationId: z3.string().min(1),
+  staticNodeId: z3.string().min(1).optional(),
+  confidence: confidenceSchema,
+  reason: z3.string().min(1),
+  evidence: z3.array(mappingEvidenceSchema)
+}).strict();
+var executionOverlayDocumentSchema = z3.object({
+  schemaVersion: z3.literal("temporal-overlay/v1"),
+  artifactId: z3.string().min(1),
+  staticAnalysisId: z3.string().min(1),
+  runtimeTraceId: z3.string().min(1),
+  workflow: z3.string().min(1),
+  staticNodes: z3.array(staticOverlayNodeSchema),
+  mappings: z3.array(runtimeNodeMappingSchema),
+  branchOutcomes: z3.array(z3.unknown()),
+  coverage: z3.object({
+    nodes: z3.object({
+      total: z3.number().int().nonnegative(),
+      observed: z3.number().int().nonnegative(),
+      skipped: z3.number().int().nonnegative(),
+      unmappedRuntimeOperations: z3.number().int().nonnegative()
+    }).strict(),
+    activities: z3.object({
+      staticTotal: z3.number().int().nonnegative(),
+      observed: z3.number().int().nonnegative(),
+      retried: z3.number().int().nonnegative(),
+      failed: z3.number().int().nonnegative()
+    }).strict(),
+    messages: z3.object({
+      staticSignals: z3.number().int().nonnegative(),
+      receivedSignals: z3.array(z3.string()),
+      staticUpdates: z3.number().int().nonnegative(),
+      receivedUpdates: z3.array(z3.string()),
+      staticQueries: z3.number().int().nonnegative()
+    }).strict(),
+    timers: z3.object({
+      staticTotal: z3.number().int().nonnegative(),
+      fired: z3.number().int().nonnegative(),
+      canceled: z3.number().int().nonnegative(),
+      pending: z3.number().int().nonnegative()
+    }).strict()
+  }).strict(),
+  diagnostics: z3.array(diagnosticSchema)
+}).strict();
+
+// packages/schemas/src/temporal-trace.ts
+import { z as z4 } from "zod";
+var eventReferenceSchema = z4.object({
+  eventId: z4.number().int().positive(),
+  eventType: z4.string().min(1)
+}).strict();
+var payloadReferenceSchema = z4.object({
+  id: z4.string().min(1),
+  eventId: z4.number().int().positive(),
+  kind: z4.union([
+    z4.literal("input"),
+    z4.literal("result"),
+    z4.literal("failure"),
+    z4.literal("signal"),
+    z4.literal("update")
+  ]),
+  decoded: z4.boolean(),
+  preview: z4.unknown().optional(),
+  redacted: z4.boolean()
+}).strict();
+var activityAttemptSchema = z4.object({
+  attempt: z4.number().int().positive(),
+  scheduledEventId: z4.number().int().positive(),
+  startedEventId: z4.number().int().positive().optional(),
+  closedEventId: z4.number().int().positive().optional(),
+  status: z4.union([
+    z4.literal("completed"),
+    z4.literal("failed"),
+    z4.literal("timedOut"),
+    z4.literal("canceled"),
+    z4.literal("pending")
+  ])
+}).strict();
+var workflowLifecycleOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("workflow-lifecycle"),
+  status: z4.union([
+    z4.literal("started"),
+    z4.literal("completed"),
+    z4.literal("failed"),
+    z4.literal("canceled"),
+    z4.literal("terminated"),
+    z4.literal("timedOut"),
+    z4.literal("continued-as-new")
+  ]),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var activityExecutionOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("activity"),
+  activityType: z4.string().min(1),
+  activityId: z4.string().min(1),
+  status: z4.union([
+    z4.literal("completed"),
+    z4.literal("failed"),
+    z4.literal("timedOut"),
+    z4.literal("canceled"),
+    z4.literal("pending")
+  ]),
+  attempts: z4.array(activityAttemptSchema),
+  firstScheduledAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().optional(),
+  durationMs: z4.number().nonnegative().optional(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var signalDeliveryOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("signal"),
+  signalName: z4.string().min(1),
+  receivedAt: z4.string().datetime(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var timerOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("timer"),
+  timerId: z4.string().min(1),
+  status: z4.union([z4.literal("fired"), z4.literal("canceled"), z4.literal("pending")]),
+  startedAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().optional(),
+  durationText: z4.string().min(1).optional(),
+  eventReferences: z4.array(eventReferenceSchema)
+}).strict();
+var updateOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("update"),
+  updateId: z4.string().min(1),
+  updateName: z4.string().min(1),
+  status: z4.union([z4.literal("accepted"), z4.literal("completed"), z4.literal("failed")]),
+  acceptedAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().optional(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var childWorkflowOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("child-workflow"),
+  workflowType: z4.string().min(1),
+  childWorkflowId: z4.string().min(1),
+  childRunId: z4.string().min(1).optional(),
+  status: z4.union([
+    z4.literal("initiated"),
+    z4.literal("startFailed"),
+    z4.literal("started"),
+    z4.literal("completed"),
+    z4.literal("failed"),
+    z4.literal("canceled"),
+    z4.literal("timedOut"),
+    z4.literal("terminated")
+  ]),
+  initiatedAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().optional(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var externalSignalOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("external-signal"),
+  signalName: z4.string().min(1),
+  targetWorkflowId: z4.string().min(1),
+  targetRunId: z4.string().min(1).optional(),
+  status: z4.union([z4.literal("initiated"), z4.literal("signaled"), z4.literal("failed")]),
+  initiatedAt: z4.string().datetime(),
+  closedAt: z4.string().datetime().optional(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var markerOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("marker"),
+  markerName: z4.string().min(1),
+  patchId: z4.string().min(1).optional(),
+  deprecated: z4.boolean().optional(),
+  recordedAt: z4.string().datetime(),
+  eventReferences: z4.array(eventReferenceSchema)
+}).strict();
+var continueAsNewOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("continue-as-new"),
+  newRunId: z4.string().min(1).optional(),
+  occurredAt: z4.string().datetime(),
+  eventReferences: z4.array(eventReferenceSchema),
+  payloadReferences: z4.array(z4.string().min(1))
+}).strict();
+var cancelRequestOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("cancel-request"),
+  requestedAt: z4.string().datetime(),
+  eventReferences: z4.array(eventReferenceSchema)
+}).strict();
+var unmappedHistoryOperationSchema = z4.object({
+  id: z4.string().min(1),
+  kind: z4.literal("unmapped"),
+  eventReferences: z4.array(eventReferenceSchema),
+  reason: z4.string().min(1)
+}).strict();
+var runtimeOperationSchema = z4.discriminatedUnion("kind", [
+  workflowLifecycleOperationSchema,
+  activityExecutionOperationSchema,
+  signalDeliveryOperationSchema,
+  timerOperationSchema,
+  updateOperationSchema,
+  childWorkflowOperationSchema,
+  externalSignalOperationSchema,
+  markerOperationSchema,
+  continueAsNewOperationSchema,
+  cancelRequestOperationSchema,
+  unmappedHistoryOperationSchema
+]);
+var runtimeTimelineEntrySchema = z4.object({
+  id: z4.string().min(1),
+  operationId: z4.string().min(1),
+  at: z4.string().datetime(),
+  label: z4.string().min(1),
+  eventIds: z4.array(z4.number().int().positive())
+}).strict();
+var runtimeTraceDocumentSchema = z4.object({
+  schemaVersion: z4.literal("temporal-trace/v1"),
+  artifactId: z4.string().min(1),
+  metadata: artifactMetadataSchema,
+  execution: z4.object({
+    workflowType: z4.string().min(1),
+    workflowId: z4.string().min(1),
+    runId: z4.string().min(1),
+    status: z4.union([
+      z4.literal("running"),
+      z4.literal("completed"),
+      z4.literal("failed"),
+      z4.literal("canceled"),
+      z4.literal("terminated"),
+      z4.literal("timedOut"),
+      z4.literal("continued-as-new")
+    ]),
+    startedAt: z4.string().datetime(),
+    closedAt: z4.string().datetime().optional(),
+    durationMs: z4.number().nonnegative().optional()
+  }).strict(),
+  source: z4.object({
+    namespace: z4.string().min(1).optional(),
+    taskQueue: z4.string().min(1).optional(),
+    eventCount: z4.number().int().nonnegative(),
+    importedFrom: z4.union([z4.literal("file"), z4.literal("api"), z4.literal("cli")])
+  }).strict(),
+  operations: z4.array(runtimeOperationSchema),
+  timeline: z4.array(runtimeTimelineEntrySchema),
+  payloads: z4.array(payloadReferenceSchema),
+  diagnostics: z4.array(diagnosticSchema)
+}).strict();
+
+// packages/schemas/src/index.ts
+var artifactSchemaVersions = {
+  analysis: "temporal-analysis/v1",
+  trace: "temporal-trace/v1",
+  overlay: "temporal-overlay/v1"
+};
+var artifactSchemaVersionValues = new Set(Object.values(artifactSchemaVersions));
+function isTemporalExplorerArtifactSchemaVersion(value) {
+  return artifactSchemaVersionValues.has(value);
+}
+var artifactSchemasByVersion = {
+  [artifactSchemaVersions.analysis]: temporalAnalysisDocumentSchema,
+  [artifactSchemaVersions.trace]: runtimeTraceDocumentSchema,
+  [artifactSchemaVersions.overlay]: executionOverlayDocumentSchema
+};
+function getSchemaVersion(value) {
+  if (!value || typeof value !== "object" || !("schemaVersion" in value)) {
+    return;
+  }
+  const candidate = value.schemaVersion;
+  return typeof candidate === "string" ? candidate : undefined;
+}
+function formatZodIssue(issue) {
+  return {
+    path: issue.path.length > 0 ? issue.path.join(".") : "<root>",
+    message: issue.message
+  };
+}
+function validateArtifact(value) {
+  const schemaVersion = getSchemaVersion(value);
+  if (!schemaVersion) {
+    return {
+      success: false,
+      code: "TES_MISSING_SCHEMA_VERSION",
+      issues: [{ path: "schemaVersion", message: "Artifact is missing schemaVersion." }]
+    };
+  }
+  if (!isTemporalExplorerArtifactSchemaVersion(schemaVersion)) {
+    return {
+      success: false,
+      code: "TES_UNSUPPORTED_SCHEMA_VERSION",
+      issues: [
+        {
+          path: "schemaVersion",
+          message: `Unsupported artifact schema version: ${schemaVersion}. This build supports ${Object.values(artifactSchemaVersions).join(", ")}; newer artifacts require upgrading temporal-explorer.`
+        }
+      ]
+    };
+  }
+  const result = artifactSchemasByVersion[schemaVersion].safeParse(value);
+  if (!result.success) {
+    return {
+      success: false,
+      code: "TES_SCHEMA_VALIDATION_FAILED",
+      schemaVersion,
+      issues: result.error.issues.map(formatZodIssue)
+    };
+  }
+  return {
+    success: true,
+    schemaVersion,
+    value: result.data,
+    issues: []
+  };
+}
+
+// packages/api/src/result.ts
+var temporalExplorerArtifactVersions = artifactSchemaVersions;
+function getTemporalExplorerVersion() {
+  return "0.0.0-mvp";
+}
+function createTemporalExplorerResult(value, options = {}) {
+  return {
+    value,
+    diagnostics: options.diagnostics ?? [],
+    warnings: options.warnings ?? [],
+    artifacts: options.artifacts ?? [],
+    metadata: options.metadata ?? {
+      temporalExplorerVersion: getTemporalExplorerVersion(),
+      schemaVersion: temporalExplorerArtifactVersions.analysis,
+      inputs: {
+        projectRoot: "",
+        configHash: "",
+        sourceFileHashes: {},
+        temporalSdkVersions: {}
+      }
+    }
+  };
+}
+// packages/api/src/library-parity.ts
+function renderMarkdown(options) {
+  const contents = options.workflowName ? renderWorkflowMarkdown({ ...options, workflowName: options.workflowName }) : renderWorkflowIndexMarkdown(options);
+  return createTemporalExplorerResult(contents, {
+    metadata: options.analysis.metadata
+  });
+}
+function renderWorkflowJson(options) {
+  const workflow = options.analysis.workflows.find((candidate) => candidate.name === options.workflow);
+  if (!workflow) {
+    throw new Error(`Workflow "${options.workflow}" was not found.`);
+  }
+  return createTemporalExplorerResult(workflow, {
+    diagnostics: workflow.diagnostics,
+    metadata: options.analysis.metadata
+  });
+}
+function renderTypeDeclarations(options) {
+  const workflows = options.workflowName ? options.analysis.workflows.filter((workflow) => workflow.name === options.workflowName) : options.analysis.workflows;
+  if (options.workflowName && workflows.length === 0) {
+    throw new Error(`Workflow "${options.workflowName}" was not found.`);
+  }
+  const files = workflows.toSorted((left, right) => left.name.localeCompare(right.name)).map((workflow) => ({
+    path: `${workflow.name}.d.ts`,
+    contents: renderWorkflowDeclaration(options.analysis, workflow.name)
+  }));
+  return createTemporalExplorerResult(files, {
+    metadata: options.analysis.metadata
+  });
+}
+function isLoadedProject(value) {
+  return typeof value.root === "string" && typeof value.tsconfig === "string" && Array.isArray(value.workflowFiles) && "outputDirectory" in value;
+}
+async function runDiagnostics(projectOrOptions = {}) {
+  const project = isLoadedProject(projectOrOptions) ? projectOrOptions : await loadTemporalExplorerProject(projectOrOptions);
+  const analysis = await analyzeProject(project);
+  const diagnostics = applySeverityOverrides(analysis.diagnostics, project.configuration?.diagnostics);
+  return createTemporalExplorerResult(diagnostics, {
+    diagnostics,
+    warnings: diagnostics.filter((diagnostic) => diagnostic.severity === "warning"),
+    metadata: analysis.metadata
+  });
+}
+
+// packages/api/src/index.ts
+function isTemporalExplorerProject(value) {
+  const candidate = value && typeof value === "object" ? value : {};
+  return typeof candidate.root === "string" && typeof candidate.tsconfig === "string" && typeof candidate.outputDirectory === "string" && Array.isArray(candidate.workflowFiles);
+}
+function isWarningDiagnostic(diagnostic) {
+  return diagnostic.severity === "warning";
+}
+function getWarningDiagnostics(diagnostics) {
+  return diagnostics.filter(isWarningDiagnostic);
+}
+async function loadTemporalExplorerProject2(options = {}) {
+  return await loadTemporalExplorerProject(options);
+}
+async function analyzeProject2(projectOrOptions = {}) {
+  const project = isTemporalExplorerProject(projectOrOptions) ? projectOrOptions : await loadTemporalExplorerProject2(projectOrOptions);
+  const analysis = await analyzeProject(project);
+  return createTemporalExplorerResult(analysis, {
+    diagnostics: analysis.diagnostics,
+    warnings: getWarningDiagnostics(analysis.diagnostics),
+    metadata: analysis.metadata
+  });
+}
+async function analyzeWorkflowFiles2(options) {
+  const analysis = await analyzeWorkflowFiles(options);
+  return createTemporalExplorerResult(analysis, {
+    diagnostics: analysis.diagnostics,
+    warnings: getWarningDiagnostics(analysis.diagnostics),
+    metadata: analysis.metadata
+  });
+}
+function parseEventHistory2(options) {
+  const trace = parseEventHistory(options);
+  return createTemporalExplorerResult(trace, {
+    diagnostics: trace.diagnostics,
+    warnings: getWarningDiagnostics(trace.diagnostics),
+    metadata: trace.metadata
+  });
+}
+async function importHistoryFromFile(options) {
+  const trace = await importEventHistoryFile(options);
+  return createTemporalExplorerResult(trace, {
+    diagnostics: trace.diagnostics,
+    warnings: getWarningDiagnostics(trace.diagnostics),
+    metadata: trace.metadata
+  });
+}
+function parseArtifactOrThrow(label, result) {
+  if (result.success) {
+    return result.data;
+  }
+  const issues = result.error.issues.map((issue) => `${issue.path.join(".") || "<root>"}: ${issue.message}`).join(`
+`);
+  throw new Error(`${label} failed schema validation:
+${issues}`);
+}
+function createExecutionOverlay2(options) {
+  const overlay = createExecutionOverlay(options);
+  return createTemporalExplorerResult(overlay, {
+    diagnostics: overlay.diagnostics,
+    warnings: getWarningDiagnostics(overlay.diagnostics),
+    metadata: options.analysis.metadata
+  });
+}
+function createExecutionOverlayFromArtifacts(options) {
+  return createExecutionOverlay2({
+    analysis: parseArtifactOrThrow("analysis artifact", temporalAnalysisDocumentSchema.safeParse(options.analysisArtifact)),
+    trace: parseArtifactOrThrow("trace artifact", runtimeTraceDocumentSchema.safeParse(options.traceArtifact)),
+    workflowName: options.workflowName,
+    ...options.replayCapture ? { replayCapture: options.replayCapture } : {}
+  });
+}
+function createOverlayReportFromArtifact(overlayArtifact) {
+  return createOverlayReport(parseArtifactOrThrow("overlay artifact", executionOverlayDocumentSchema.safeParse(overlayArtifact)));
+}
+function createDocumentationSet2(options) {
+  const files = createDocumentationSet(options);
+  return createTemporalExplorerResult(files, {
+    metadata: options.analysis.metadata
+  });
+}
+function createDocumentationSetFromArtifacts(options) {
+  return createDocumentationSet2({
+    analysis: parseArtifactOrThrow("analysis artifact", temporalAnalysisDocumentSchema.safeParse(options.analysisArtifact)),
+    traces: (options.traceArtifacts ?? []).map((artifact, index) => parseArtifactOrThrow(`trace artifact ${index + 1}`, runtimeTraceDocumentSchema.safeParse(artifact))),
+    overlays: (options.overlayArtifacts ?? []).map((artifact, index) => parseArtifactOrThrow(`overlay artifact ${index + 1}`, executionOverlayDocumentSchema.safeParse(artifact)))
+  });
+}
+function renderWorkflowMermaidFromArtifacts(options) {
+  return renderWorkflowMermaid(parseArtifactOrThrow("analysis artifact", temporalAnalysisDocumentSchema.safeParse(options.analysisArtifact)), options.workflowName);
+}
+export {
+  validateArtifact,
+  toProjectPath,
+  temporalExplorerArtifactVersions,
+  runDiagnostics,
+  renderWorkflowMermaidFromArtifacts,
+  renderWorkflowJson,
+  renderTypeDeclarations,
+  renderMarkdown,
+  parseEventHistory2 as parseEventHistory,
+  loadTemporalExplorerProject2 as loadTemporalExplorerProject,
+  listWorkflowRuns,
+  importHistoryFromFile,
+  getTemporalExplorerVersion,
+  formatAggregateReport,
+  fetchEventHistory,
+  defineConfig,
+  createTemporalExplorerResult,
+  createSourceFileHashes,
+  createOverlayReportFromArtifact,
+  createOverlayReport,
+  createLiveClient,
+  createExecutionOverlayFromArtifacts,
+  createExecutionOverlay2 as createExecutionOverlay,
+  createDocumentationSetFromArtifacts,
+  createDocumentationSet2 as createDocumentationSet,
+  createAggregateReport,
+  applySeverityOverrides,
+  analyzeWorkflowFiles2 as analyzeWorkflowFiles,
+  analyzeProject2 as analyzeProject
+};