@lostgradient/weft 0.2.0

package/dist/server/operations/get-stream-chunks.js

@@ -0,0 +1,71 @@
+import { z } from "zod";
+import { FAULT_CODE_TO_HTTP_STATUS } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+import { parseOptionalSequenceCursor } from "../sequence-cursor.js";
+import { invalidParamsFault, jsonErrorResponse } from "./operation-helpers.js";
+import { createStoredChunkSSEStream, SSE_RESPONSE_HEADERS } from "./sse-stream.js";
+const getStreamChunksInput = z.object({
+  workflowId: z.string().min(1),
+  key: z.string().min(1),
+  after: z.unknown().optional()
+});
+export const getStreamChunksOperation = defineOperation({
+  name: "weft.workflows.streams.chunks",
+  mcpExposable: !1,
+  summary: "Read stored stream chunks for a workflow stream key",
+  destructive: !1,
+  tags: ["Streams"],
+  inputSchema: getStreamChunksInput,
+  outputSchema: z.object({ chunks: z.array(z.unknown()) }),
+  access: { kind: "public" },
+  transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+  unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+  invoke: async ({ input, engine }) => {
+    const e = engine;
+    let after;
+    if (input.after !== void 0) {
+      const rawCursor = typeof input.after === "string" ? input.after : typeof input.after === "number" ? String(input.after) : "", parsed = parseOptionalSequenceCursor(rawCursor, "after query parameter");
+      if (parsed.error !== void 0)
+        throw invalidParamsFault(parsed.error);
+      after = parsed.value;
+    }
+    return { chunks: after !== void 0 ? await e.getStreamChunks(input.workflowId, input.key, { after }) : await e.getStreamChunks(input.workflowId, input.key) };
+  }
+});
+function shapeGetStreamChunksFault(fault) {
+  if (fault.code === "InvalidParams")
+    return jsonErrorResponse(fault.message, 400);
+  if (fault.code === "EngineFailure")
+    return jsonErrorResponse("Internal server error", 500);
+  return jsonErrorResponse(fault.message, FAULT_CODE_TO_HTTP_STATUS[fault.code]);
+}
+function shapeGetStreamChunksSuccess(output, request) {
+  if ((request.headers.get("Accept") ?? "").includes("text/event-stream"))
+    return new Response(createStoredChunkSSEStream(output.chunks, (chunk) => JSON.stringify({ sequence: chunk.sequence, value: chunk.value })), { status: 200, headers: SSE_RESPONSE_HEADERS });
+  return new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  });
+}
+export const getStreamChunksRestBinding = {
+  method: "GET",
+  path: "/v1/workflows/:id/streams/:key",
+  pathParamNames: ["id", "key"],
+  operationName: "weft.workflows.streams.chunks",
+  inputSources: {
+    workflowId: { kind: "path", pathParam: "id" },
+    key: { kind: "path", pathParam: "key" },
+    after: { kind: "query", queryParam: "after" }
+  },
+  extractInput: async (request, pathParams) => {
+    const rawAfter = new URL(request.url).searchParams.get("after");
+    return {
+      workflowId: pathParams.id ?? "",
+      key: pathParams.key ?? "",
+      ...rawAfter !== null ? { after: rawAfter } : {}
+    };
+  },
+  success: { kind: "streaming", mediaType: "text/event-stream" },
+  shapeSuccess: shapeGetStreamChunksSuccess,
+  shapeFault: shapeGetStreamChunksFault
+};

package/dist/server/operations/get-system-metrics.d.ts

@@ -0,0 +1,42 @@
+/**
+ * `weft.system.metrics` operation + REST binding.
+ *
+ * Returns JSON-shaped metrics. This is distinct from the Prometheus text
+ * exposition at `GET /v1/metrics` (which remains a direct handler and is
+ * REST-only). This operation exposes the same underlying data as a
+ * structured JSON object for consumers that need machine-readable metrics
+ * rather than Prometheus text format.
+ *
+ * Access is scoped to `system:read` — the same privilege class as any
+ * internal-observability endpoint.
+ *
+ * The metrics snapshot comes from server-owned state captured when the
+ * operation is registered. Callers cannot supply a snapshot through REST
+ * or JSON-RPC input.
+ *
+ * @module server/operations/get-system-metrics
+ */
+import { z } from 'zod';
+import type { MetricsCollector, MetricsSnapshot } from '../../observability/metrics.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+declare const getSystemMetricsInput: z.ZodObject<{}, z.core.$strip>;
+export type GetSystemMetricsInput = z.infer<typeof getSystemMetricsInput>;
+export type GetSystemMetricsOutput = MetricsSnapshot;
+/**
+ * Create the `weft.system.metrics` operation bound to a server-owned
+ * metrics collector.
+ */
+export declare function createGetSystemMetricsOperation(options?: {
+    metricsCollector?: MetricsCollector | undefined;
+}): import("../operation-catalog.ts").OperationDefinition<Record<string, never>, MetricsSnapshot>;
+export declare const getSystemMetricsOperation: import("../operation-catalog.ts").OperationDefinition<Record<string, never>, MetricsSnapshot>;
+/**
+ * Factory for the `weft.system.metrics` REST binding.
+ *
+ * Takes no arguments — the metrics snapshot is sourced through
+ * `createGetSystemMetricsOperation`'s closure over the server-owned
+ * collector, not through the binding. The binding only declares the
+ * REST shape (path, method, response shaping).
+ */
+export declare function createGetSystemMetricsRestBinding(): UnknownRestBinding;
+export {};

package/dist/server/operations/get-system-metrics.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { shapeOperationFaultAsJson } from "../operation-fault.js";
+import { defineOperation } from "../operation-registry.js";
+const getSystemMetricsInput = z.object({}), getSystemMetricsOutput = z.unknown();
+export function createGetSystemMetricsOperation(options) {
+  return defineOperation({
+    name: "weft.system.metrics",
+    mcpExposable: !1,
+    summary: "Get JSON-shaped system metrics",
+    destructive: !1,
+    tags: ["Observability"],
+    inputSchema: getSystemMetricsInput,
+    outputSchema: getSystemMetricsOutput,
+    access: {
+      kind: "scoped",
+      scopes: { kind: "anyOf", scopes: ["system:read"] }
+    },
+    producibleFaults: [],
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async () => {
+      return options?.metricsCollector?.snapshot() ?? {};
+    }
+  });
+}
+export const getSystemMetricsOperation = createGetSystemMetricsOperation();
+export function createGetSystemMetricsRestBinding() {
+  return {
+    method: "GET",
+    path: "/v1/metrics/json",
+    pathParamNames: [],
+    operationName: "weft.system.metrics",
+    inputSources: {},
+    extractInput: async () => ({}),
+    success: { kind: "json", status: 200 },
+    shapeSuccess: (output) => new Response(JSON.stringify(output), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    }),
+    shapeFault: shapeOperationFaultAsJson
+  };
+}

package/dist/server/operations/get-task-diagnostics.d.ts

@@ -0,0 +1,184 @@
+/**
+ * `weft.tasks.diagnostics` operation + REST binding.
+ *
+ * Scans durable task records and live worker state to identify queue pressure,
+ * stale in-flight work, retry storms, and worker capacity saturation. Results
+ * are intentionally bounded and low-cardinality so operators can use them in a
+ * dashboard without turning workflow or worker identifiers into metrics labels.
+ *
+ * @module server/operations/get-task-diagnostics
+ */
+import { z } from 'zod';
+import type { WorkerRegistry } from '../../worker/registry.ts';
+import type { UnknownRestBinding } from '../rest-bindings.ts';
+import type { TaskQueue } from '../task-queue.ts';
+declare const taskDiagnosticKindSchema: z.ZodEnum<{
+    "stuck-queued": "stuck-queued";
+    "stale-inflight": "stale-inflight";
+    "retry-storm": "retry-storm";
+    "all-workers-at-capacity": "all-workers-at-capacity";
+}>;
+declare const taskDiagnosticItemSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        "stuck-queued": "stuck-queued";
+        "stale-inflight": "stale-inflight";
+        "retry-storm": "retry-storm";
+        "all-workers-at-capacity": "all-workers-at-capacity";
+    }>;
+    state: z.ZodEnum<{
+        queued: "queued";
+        inflight: "inflight";
+        resolved: "resolved";
+        capacity: "capacity";
+    }>;
+    operationId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    activityName: z.ZodOptional<z.ZodString>;
+    queue: z.ZodOptional<z.ZodString>;
+    workerId: z.ZodOptional<z.ZodString>;
+    retryCount: z.ZodNumber;
+    requeueCount: z.ZodNumber;
+    queueLatencyMs: z.ZodOptional<z.ZodNumber>;
+    executionLatencyMs: z.ZodOptional<z.ZodNumber>;
+    heartbeatAgeMs: z.ZodOptional<z.ZodNumber>;
+    lastRequeueReason: z.ZodOptional<z.ZodEnum<{
+        "visibility-timeout": "visibility-timeout";
+        "worker-disconnect": "worker-disconnect";
+    }>>;
+    resolutionReason: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+declare const taskDiagnosticsSummarySchema: z.ZodObject<{
+    stuckQueued: z.ZodNumber;
+    staleInflight: z.ZodNumber;
+    retryStorms: z.ZodNumber;
+    allWorkersAtCapacity: z.ZodNumber;
+}, z.core.$strict>;
+declare const getTaskDiagnosticsOutput: z.ZodObject<{
+    items: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "stuck-queued": "stuck-queued";
+            "stale-inflight": "stale-inflight";
+            "retry-storm": "retry-storm";
+            "all-workers-at-capacity": "all-workers-at-capacity";
+        }>;
+        state: z.ZodEnum<{
+            queued: "queued";
+            inflight: "inflight";
+            resolved: "resolved";
+            capacity: "capacity";
+        }>;
+        operationId: z.ZodOptional<z.ZodString>;
+        workflowId: z.ZodOptional<z.ZodString>;
+        activityName: z.ZodOptional<z.ZodString>;
+        queue: z.ZodOptional<z.ZodString>;
+        workerId: z.ZodOptional<z.ZodString>;
+        retryCount: z.ZodNumber;
+        requeueCount: z.ZodNumber;
+        queueLatencyMs: z.ZodOptional<z.ZodNumber>;
+        executionLatencyMs: z.ZodOptional<z.ZodNumber>;
+        heartbeatAgeMs: z.ZodOptional<z.ZodNumber>;
+        lastRequeueReason: z.ZodOptional<z.ZodEnum<{
+            "visibility-timeout": "visibility-timeout";
+            "worker-disconnect": "worker-disconnect";
+        }>>;
+        resolutionReason: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    summary: z.ZodObject<{
+        stuckQueued: z.ZodNumber;
+        staleInflight: z.ZodNumber;
+        retryStorms: z.ZodNumber;
+        allWorkersAtCapacity: z.ZodNumber;
+    }, z.core.$strict>;
+    limit: z.ZodNumber;
+}, z.core.$strict>;
+declare const getTaskDiagnosticsInput: z.ZodObject<{
+    operationId: z.ZodOptional<z.ZodString>;
+    workflowId: z.ZodOptional<z.ZodString>;
+    queue: z.ZodOptional<z.ZodString>;
+    staleQueuedAfterMs: z.ZodDefault<z.ZodNumber>;
+    staleHeartbeatAfterMs: z.ZodDefault<z.ZodNumber>;
+    retryStormMinimumAttempts: z.ZodDefault<z.ZodNumber>;
+    limit: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type GetTaskDiagnosticsInput = z.infer<typeof getTaskDiagnosticsInput>;
+export type TaskDiagnosticKind = z.infer<typeof taskDiagnosticKindSchema>;
+export type TaskDiagnosticItem = z.infer<typeof taskDiagnosticItemSchema>;
+export type TaskDiagnosticsSummary = z.infer<typeof taskDiagnosticsSummarySchema>;
+export type GetTaskDiagnosticsOutput = z.infer<typeof getTaskDiagnosticsOutput>;
+interface GetTaskDiagnosticsOptions {
+    registry?: WorkerRegistry | undefined;
+    taskQueue?: TaskQueue | undefined;
+    now?: (() => number) | undefined;
+}
+export declare function createGetTaskDiagnosticsOperation(options?: GetTaskDiagnosticsOptions): import("../operation-catalog.ts").OperationDefinition<{
+    staleQueuedAfterMs: number;
+    staleHeartbeatAfterMs: number;
+    retryStormMinimumAttempts: number;
+    limit: number;
+    operationId?: string | undefined;
+    workflowId?: string | undefined;
+    queue?: string | undefined;
+}, {
+    items: {
+        kind: "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
+        state: "queued" | "inflight" | "resolved" | "capacity";
+        retryCount: number;
+        requeueCount: number;
+        evidence: string[];
+        operationId?: string | undefined;
+        workflowId?: string | undefined;
+        activityName?: string | undefined;
+        queue?: string | undefined;
+        workerId?: string | undefined;
+        queueLatencyMs?: number | undefined;
+        executionLatencyMs?: number | undefined;
+        heartbeatAgeMs?: number | undefined;
+        lastRequeueReason?: "visibility-timeout" | "worker-disconnect" | undefined;
+        resolutionReason?: string | undefined;
+    }[];
+    summary: {
+        stuckQueued: number;
+        staleInflight: number;
+        retryStorms: number;
+        allWorkersAtCapacity: number;
+    };
+    limit: number;
+}>;
+export declare const getTaskDiagnosticsOperation: import("../operation-catalog.ts").OperationDefinition<{
+    staleQueuedAfterMs: number;
+    staleHeartbeatAfterMs: number;
+    retryStormMinimumAttempts: number;
+    limit: number;
+    operationId?: string | undefined;
+    workflowId?: string | undefined;
+    queue?: string | undefined;
+}, {
+    items: {
+        kind: "stuck-queued" | "stale-inflight" | "retry-storm" | "all-workers-at-capacity";
+        state: "queued" | "inflight" | "resolved" | "capacity";
+        retryCount: number;
+        requeueCount: number;
+        evidence: string[];
+        operationId?: string | undefined;
+        workflowId?: string | undefined;
+        activityName?: string | undefined;
+        queue?: string | undefined;
+        workerId?: string | undefined;
+        queueLatencyMs?: number | undefined;
+        executionLatencyMs?: number | undefined;
+        heartbeatAgeMs?: number | undefined;
+        lastRequeueReason?: "visibility-timeout" | "worker-disconnect" | undefined;
+        resolutionReason?: string | undefined;
+    }[];
+    summary: {
+        stuckQueued: number;
+        staleInflight: number;
+        retryStorms: number;
+        allWorkersAtCapacity: number;
+    };
+    limit: number;
+}>;
+export declare const getTaskDiagnosticsRestBinding: UnknownRestBinding;
+export {};

package/dist/server/operations/get-task-diagnostics.js

@@ -0,0 +1,340 @@
+import { z } from "zod";
+import { decode } from "../../core/codec.js";
+import { KEYS } from "../../storage/interface.js";
+import { defineOperation } from "../operation-registry.js";
+import {
+  calculateExecutionLatencyMs,
+  calculateHeartbeatAgeMs,
+  calculateQueueLatencyMs,
+  isInflightRecord,
+  isQueuedRecord,
+  isResolvedRecord
+} from "../task-state.js";
+import { shapeRestFault } from "./operation-helpers.js";
+const DEFAULT_STALE_QUEUED_AFTER_MS = 60000, DEFAULT_STALE_HEARTBEAT_AFTER_MS = 60000, DEFAULT_RETRY_STORM_MINIMUM_ATTEMPTS = 3, DEFAULT_LIMIT = 50, MAX_LIMIT = 200, RESOLVED_HISTORY_SCAN_LIMIT = 1000, taskDiagnosticKindSchema = z.enum([
+  "stuck-queued",
+  "stale-inflight",
+  "retry-storm",
+  "all-workers-at-capacity"
+]), taskDiagnosticItemSchema = z.object({
+  kind: taskDiagnosticKindSchema,
+  state: z.enum(["queued", "inflight", "resolved", "capacity"]),
+  operationId: z.string().optional(),
+  workflowId: z.string().optional(),
+  activityName: z.string().optional(),
+  queue: z.string().optional(),
+  workerId: z.string().optional(),
+  retryCount: z.number().int().nonnegative(),
+  requeueCount: z.number().int().nonnegative(),
+  queueLatencyMs: z.number().nonnegative().optional(),
+  executionLatencyMs: z.number().nonnegative().optional(),
+  heartbeatAgeMs: z.number().nonnegative().optional(),
+  lastRequeueReason: z.enum(["visibility-timeout", "worker-disconnect"]).optional(),
+  resolutionReason: z.string().optional(),
+  evidence: z.array(z.string())
+}).strict(), taskDiagnosticsSummarySchema = z.object({
+  stuckQueued: z.number().int().nonnegative(),
+  staleInflight: z.number().int().nonnegative(),
+  retryStorms: z.number().int().nonnegative(),
+  allWorkersAtCapacity: z.number().int().nonnegative()
+}).strict(), getTaskDiagnosticsOutput = z.object({
+  items: z.array(taskDiagnosticItemSchema),
+  summary: taskDiagnosticsSummarySchema,
+  limit: z.number().int().min(1).max(MAX_LIMIT)
+}).strict(), getTaskDiagnosticsInput = z.object({
+  operationId: z.string().min(1).optional(),
+  workflowId: z.string().min(1).optional(),
+  queue: z.string().min(1).optional(),
+  staleQueuedAfterMs: z.number().int().nonnegative().default(DEFAULT_STALE_QUEUED_AFTER_MS),
+  staleHeartbeatAfterMs: z.number().int().nonnegative().default(DEFAULT_STALE_HEARTBEAT_AFTER_MS),
+  retryStormMinimumAttempts: z.number().int().min(1).default(DEFAULT_RETRY_STORM_MINIMUM_ATTEMPTS),
+  limit: z.number().int().min(1).max(MAX_LIMIT).default(DEFAULT_LIMIT)
+});
+export function createGetTaskDiagnosticsOperation(options = {}) {
+  return defineOperation({
+    name: "weft.tasks.diagnostics",
+    mcpExposable: !1,
+    summary: "Get bounded task latency and stuck-work diagnostics",
+    destructive: !1,
+    tags: ["Observability"],
+    inputSchema: getTaskDiagnosticsInput,
+    outputSchema: getTaskDiagnosticsOutput,
+    access: {
+      kind: "scoped",
+      scopes: { kind: "anyOf", scopes: ["system:read"] }
+    },
+    producibleFaults: [],
+    discoverable: !0,
+    transports: { http: !0, jsonRpcHttp: !0, jsonRpcWebSocket: !0, jsonRpcStdio: !0 },
+    unknownKeyPolicy: { http: "strip", jsonRpc: "reject" },
+    invoke: async ({ input, engine }) => {
+      const currentTime = options.now?.() ?? Date.now();
+      return collectTaskDiagnostics({
+        engine,
+        input,
+        currentTime,
+        registry: options.registry,
+        taskQueue: options.taskQueue
+      });
+    }
+  });
+}
+export const getTaskDiagnosticsOperation = createGetTaskDiagnosticsOperation();
+async function collectTaskDiagnostics({
+  engine,
+  input,
+  currentTime,
+  registry,
+  taskQueue
+}) {
+  const items = [], summary = {
+    stuckQueued: 0,
+    staleInflight: 0,
+    retryStorms: 0,
+    allWorkersAtCapacity: 0
+  }, relevantQueues = new Set, addItem = (item) => {
+    incrementSummary(summary, item.kind);
+    if (items.length < input.limit)
+      items.push(item);
+  };
+  for await (const record of scanQueuedRecords(engine)) {
+    if (!matchesTaskRecordFilter(record, input))
+      continue;
+    relevantQueues.add(record.queue);
+    addQueuedDiagnostics(record, input, currentTime, addItem);
+  }
+  for await (const record of scanInflightRecords(engine)) {
+    if (!matchesTaskRecordFilter(record, input))
+      continue;
+    relevantQueues.add(record.queue);
+    addInflightDiagnostics(record, input, currentTime, addItem);
+  }
+  for await (const record of scanResolvedRecords(engine, input)) {
+    if (!matchesTaskRecordFilter(record, input))
+      continue;
+    if (record.queue !== void 0)
+      relevantQueues.add(record.queue);
+    addRetryStormDiagnostic(record, "resolved", input, addItem);
+  }
+  addCapacityDiagnostics({
+    registry,
+    taskQueue,
+    input,
+    queues: relevantQueues,
+    addItem
+  });
+  return { items, summary, limit: input.limit };
+}
+async function* scanQueuedRecords(engine) {
+  for await (const [, value] of engine.storage.scan("op:queued:")) {
+    const decoded = decode(value);
+    if (isQueuedRecord(decoded))
+      yield decoded;
+  }
+}
+async function* scanInflightRecords(engine) {
+  for await (const [, value] of engine.storage.scan("op:inflight:")) {
+    const decoded = decode(value);
+    if (isInflightRecord(decoded))
+      yield decoded;
+  }
+}
+async function* scanResolvedRecords(engine, input) {
+  if (input.operationId !== void 0) {
+    const value = await engine.storage.get(KEYS.operationResolved(input.operationId));
+    if (value === null)
+      return;
+    const decoded = decode(value);
+    if (isResolvedRecord(decoded))
+      yield decoded;
+    return;
+  }
+  for await (const [, value] of engine.storage.scan(KEYS.operationResolvedByTimePrefix(), {
+    limit: RESOLVED_HISTORY_SCAN_LIMIT,
+    reverse: !0
+  })) {
+    const decoded = decode(value);
+    if (isResolvedRecord(decoded))
+      yield decoded;
+  }
+}
+function addQueuedDiagnostics(record, input, currentTime, addItem) {
+  const queuedAt = record.lastQueuedAt ?? record.queuedAt, queueLatencyMs = Math.max(0, currentTime - queuedAt);
+  if (queueLatencyMs >= input.staleQueuedAfterMs)
+    addItem({
+      kind: "stuck-queued",
+      state: "queued",
+      operationId: record.operationId,
+      workflowId: record.workflowId,
+      activityName: record.activityName,
+      queue: record.queue,
+      retryCount: record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1),
+      requeueCount: record.requeueCount ?? 0,
+      queueLatencyMs,
+      lastRequeueReason: record.lastRequeueReason,
+      evidence: [
+        `Task has waited ${queueLatencyMs}ms in queue "${record.queue}" without a worker claim`
+      ]
+    });
+  addRetryStormDiagnostic(record, "queued", input, addItem);
+}
+function addInflightDiagnostics(record, input, currentTime, addItem) {
+  const heartbeatAgeMs = calculateHeartbeatAgeMs(record, currentTime) ?? 0;
+  if (heartbeatAgeMs >= input.staleHeartbeatAfterMs)
+    addItem({
+      kind: "stale-inflight",
+      state: "inflight",
+      operationId: record.operationId,
+      workflowId: record.workflowId,
+      activityName: record.activityName,
+      queue: record.queue,
+      workerId: record.workerId,
+      retryCount: record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1),
+      requeueCount: record.requeueCount ?? 0,
+      queueLatencyMs: calculateQueueLatencyMs(record),
+      executionLatencyMs: calculateExecutionLatencyMs(record, currentTime),
+      heartbeatAgeMs,
+      lastRequeueReason: record.lastRequeueReason,
+      evidence: [
+        `Worker "${record.workerId}" has not sent a heartbeat for ${heartbeatAgeMs}ms on queue "${record.queue}"`
+      ]
+    });
+  addRetryStormDiagnostic(record, "inflight", input, addItem);
+}
+function addRetryStormDiagnostic(record, state, input, addItem) {
+  const retryCount = record.retryCount ?? Math.max(0, (record.attempt ?? 1) - 1), requeueCount = record.requeueCount ?? 0;
+  if (retryCount < input.retryStormMinimumAttempts && requeueCount < input.retryStormMinimumAttempts)
+    return;
+  addItem({
+    kind: "retry-storm",
+    state,
+    operationId: record.operationId,
+    workflowId: record.workflowId,
+    activityName: "activityName" in record ? record.activityName : void 0,
+    queue: record.queue,
+    workerId: "workerId" in record ? record.workerId : void 0,
+    retryCount,
+    requeueCount,
+    queueLatencyMs: calculateQueueLatencyMs(record),
+    executionLatencyMs: "resolvedAt" in record ? calculateExecutionLatencyMs(record, record.resolvedAt) : void 0,
+    lastRequeueReason: record.lastRequeueReason,
+    resolutionReason: "resolutionReason" in record ? record.resolutionReason : void 0,
+    evidence: [
+      `Task has ${retryCount} retries and ${requeueCount} requeues, meeting retry storm threshold ${input.retryStormMinimumAttempts}`
+    ]
+  });
+}
+function addCapacityDiagnostics({
+  registry,
+  taskQueue,
+  input,
+  queues,
+  addItem
+}) {
+  if (registry === void 0 || taskQueue === void 0)
+    return;
+  const workersByQueue = groupWorkersByQueue(registry), candidateQueues = selectCapacityDiagnosticQueues(input, queues, workersByQueue);
+  for (const queue of candidateQueues) {
+    const diagnostic = buildCapacityDiagnostic(queue, workersByQueue, taskQueue);
+    if (diagnostic === null)
+      continue;
+    addItem(diagnostic);
+  }
+}
+function groupWorkersByQueue(registry) {
+  const workersByQueue = new Map;
+  for (const worker of registry.getAll()) {
+    const workers = workersByQueue.get(worker.queue) ?? [];
+    workers.push(worker);
+    workersByQueue.set(worker.queue, workers);
+  }
+  return workersByQueue;
+}
+function selectCapacityDiagnosticQueues(input, queues, workersByQueue) {
+  if (input.queue !== void 0)
+    return [input.queue];
+  if (queues.size > 0)
+    return [...queues];
+  if (input.operationId !== void 0 || input.workflowId !== void 0)
+    return [];
+  return [...workersByQueue.keys()];
+}
+function buildCapacityDiagnostic(queue, workersByQueue, taskQueue) {
+  const workers = workersByQueue.get(queue) ?? [], pendingCount = taskQueue.pendingCount(queue);
+  if (workers.length === 0 || pendingCount === 0)
+    return null;
+  const totalCapacity = workers.reduce((sum, worker) => sum + worker.concurrency, 0), totalInFlight = workers.reduce((sum, worker) => sum + worker.inFlight, 0);
+  if (totalCapacity === 0 || totalInFlight < totalCapacity)
+    return null;
+  return {
+    kind: "all-workers-at-capacity",
+    state: "capacity",
+    queue,
+    retryCount: 0,
+    requeueCount: 0,
+    evidence: [
+      `Queue "${queue}" has ${pendingCount} pending tasks and all ${workers.length} workers at capacity`
+    ]
+  };
+}
+function matchesTaskRecordFilter(record, input) {
+  if (input.operationId !== void 0 && record.operationId !== input.operationId)
+    return !1;
+  if (input.workflowId !== void 0 && record.workflowId !== input.workflowId)
+    return !1;
+  if (input.queue !== void 0 && record.queue !== input.queue)
+    return !1;
+  return !0;
+}
+function incrementSummary(summary, kind) {
+  switch (kind) {
+    case "stuck-queued":
+      summary.stuckQueued += 1;
+      return;
+    case "stale-inflight":
+      summary.staleInflight += 1;
+      return;
+    case "retry-storm":
+      summary.retryStorms += 1;
+      return;
+    case "all-workers-at-capacity":
+      summary.allWorkersAtCapacity += 1;
+      return;
+  }
+}
+function parseOptionalNumber(value) {
+  return value === null || value.length === 0 ? void 0 : Number(value);
+}
+export const getTaskDiagnosticsRestBinding = {
+  method: "GET",
+  path: "/v1/tasks/diagnostics",
+  pathParamNames: [],
+  operationName: "weft.tasks.diagnostics",
+  inputSources: {
+    operationId: { kind: "query", queryParam: "operationId" },
+    workflowId: { kind: "query", queryParam: "workflowId" },
+    queue: { kind: "query", queryParam: "queue" },
+    staleQueuedAfterMs: { kind: "query", queryParam: "staleQueuedAfterMs" },
+    staleHeartbeatAfterMs: { kind: "query", queryParam: "staleHeartbeatAfterMs" },
+    retryStormMinimumAttempts: { kind: "query", queryParam: "retryStormMinimumAttempts" },
+    limit: { kind: "query", queryParam: "limit" }
+  },
+  extractInput: async (request) => {
+    const url = new URL(request.url);
+    return {
+      operationId: url.searchParams.get("operationId") ?? void 0,
+      workflowId: url.searchParams.get("workflowId") ?? void 0,
+      queue: url.searchParams.get("queue") ?? void 0,
+      staleQueuedAfterMs: parseOptionalNumber(url.searchParams.get("staleQueuedAfterMs")),
+      staleHeartbeatAfterMs: parseOptionalNumber(url.searchParams.get("staleHeartbeatAfterMs")),
+      retryStormMinimumAttempts: parseOptionalNumber(url.searchParams.get("retryStormMinimumAttempts")),
+      limit: parseOptionalNumber(url.searchParams.get("limit"))
+    };
+  },
+  success: { kind: "json", status: 200 },
+  shapeSuccess: (output) => new Response(JSON.stringify(output), {
+    status: 200,
+    headers: { "Content-Type": "application/json" }
+  }),
+  shapeFault: shapeRestFault
+};