temporal-explorer 0.0.0-mvp

package/dist/schemas/index.js

@@ -0,0 +1,612 @@
+// @bun
+// 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: []
+  };
+}
+export {
+  workflowSignatureSchema,
+  workflowLifecycleOperationSchema,
+  workflowDependencySchema,
+  workflowDefinitionSchema,
+  validateArtifact,
+  updateOperationSchema,
+  updateDefinitionSchema,
+  unmappedHistoryOperationSchema,
+  timerOperationSchema,
+  temporalCommandSchema,
+  temporalAnalysisDocumentSchema,
+  staticOverlayNodeSchema,
+  sourcePositionSchema,
+  sourceLocationSchema,
+  signalDeliveryOperationSchema,
+  signalDefinitionSchema,
+  runtimeTraceDocumentSchema,
+  runtimeTimelineEntrySchema,
+  runtimeOperationSchema,
+  runtimeNodeMappingSchema,
+  queryDefinitionSchema,
+  payloadReferenceSchema,
+  markerOperationSchema,
+  mappingEvidenceSchema,
+  isTemporalExplorerArtifactSchemaVersion,
+  externalSignalOperationSchema,
+  executionOverlayDocumentSchema,
+  eventReferenceSchema,
+  diagnosticSchema,
+  continueAsNewOperationSchema,
+  confidenceSchema,
+  childWorkflowOperationSchema,
+  cancelRequestOperationSchema,
+  artifactSchemasByVersion,
+  artifactSchemaVersions,
+  artifactMetadataSchema,
+  activityExecutionOperationSchema,
+  activityDefinitionSchema,
+  activityAttemptSchema
+};