@axlsdk/studio 0.26.0 → 0.27.1

package/dist/middleware.js

@@ -1,7 +1,7 @@
 import {
   createServer,
   handleWsMessage
-} from "./chunk-HAKTKSZS.js";
+} from "./chunk-MKL6RKQ4.js";
 
 // src/middleware.ts
 import { resolve as resolve2, dirname } from "path";

package/dist/server/index.cjs

@@ -65,6 +65,12 @@ function redactValue(value, redact) {
 }
 function redactExecutionInfo(info, redact) {
   if (!redact) return info;
+  return {
+    ...redactExecutionFields(info),
+    events: info.events.map((e) => redactStreamEvent(e, true))
+  };
+}
+function redactExecutionFields(info) {
   return {
     ...info,
     ...info.result !== void 0 ? { result: REDACTED } : {},
@@ -76,13 +82,13 @@ function redactExecutionInfo(info, redact) {
     // scrubbed. Use a `{ redacted: true }` marker to keep the field
     // queryable/serializable rather than dropping it (mirrors
     // `redactPendingDecision` on `decision.metadata`).
-    ...info.metadata !== void 0 ? { metadata: { redacted: true } } : {},
-    events: info.events.map((e) => redactStreamEvent(e, true))
+    ...info.metadata !== void 0 ? { metadata: { redacted: true } } : {}
   };
 }
-function redactExecutionList(infos, redact) {
-  if (!redact) return infos;
-  return infos.map((info) => redactExecutionInfo(info, redact));
+function summarizeExecution(info, redact) {
+  const { events, ...rest } = info;
+  const summary = { ...rest, eventCount: events.length };
+  return redact ? redactExecutionFields(summary) : summary;
 }
 function redactMemoryValue(value, redact) {
   if (!redact) return value;
@@ -693,6 +699,29 @@ function createWsHandlers(connMgr) {
   };
 }
 
+// src/server/aggregates/coalesced-runner.ts
+var CoalescedRunner = class {
+  constructor(task) {
+    this.task = task;
+  }
+  current;
+  trailing;
+  run() {
+    if (!this.current) {
+      const started = this.task().finally(() => {
+        this.current = void 0;
+      });
+      this.current = started;
+      return started;
+    }
+    this.trailing ??= this.current.catch(() => void 0).then(() => {
+      this.trailing = void 0;
+      return this.run();
+    });
+    return this.trailing;
+  }
+};
+
 // src/server/aggregates/aggregate-snapshots.ts
 var WINDOW_MS = {
   "24h": 24 * 60 * 60 * 1e3,
@@ -787,10 +816,19 @@ var TraceAggregator = class {
       REBUILD_INTERVAL_MS
     );
   }
-  async rebuild() {
-    const executions = await this.options.runtime.getExecutions();
+  /**
+   * Rebuild from the store. Requests that arrive during a rebuild (a burst of
+   * deletes, the timer) coalesce into one trailing rebuild.
+   */
+  rebuild() {
+    return this.rebuilds.run();
+  }
+  rebuilds = new CoalescedRunner(() => this.rebuildFromStore());
+  async rebuildFromStore() {
     const cap = this.options.executionCap ?? 2e3;
-    const capped = executions.slice(0, cap);
+    const capped = await this.options.runtime.getExecutions({
+      limit: cap
+    });
     const now = Date.now();
     const fresh = new Map(
       this.options.windows.map((w) => [w, this.options.emptyState()])
@@ -862,11 +900,20 @@ var ExecutionAggregator = class {
       REBUILD_INTERVAL_MS
     );
   }
-  async rebuild() {
+  /**
+   * Rebuild from the store. Requests that arrive during a rebuild (a burst of
+   * deletes, the timer) coalesce into one trailing rebuild.
+   */
+  rebuild() {
+    return this.rebuilds.run();
+  }
+  rebuilds = new CoalescedRunner(() => this.rebuildFromStore());
+  async rebuildFromStore() {
     this.generation++;
-    const executions = await this.options.runtime.getExecutions();
     const cap = this.options.executionCap ?? 2e3;
-    const capped = executions.slice(0, cap);
+    const capped = await this.options.runtime.getExecutions({
+      limit: cap
+    });
     const now = Date.now();
     const fresh = new Map(
       this.options.windows.map((w) => [w, this.options.emptyState()])
@@ -1483,16 +1530,66 @@ function createWorkflowRoutes(connMgr) {
 
 // src/server/routes/executions.ts
 var import_hono3 = require("hono");
+
+// src/server/execution-cursor.ts
+function encodeExecutionCursor(cursor) {
+  return Buffer.from(JSON.stringify(cursor), "utf8").toString("base64url");
+}
+function decodeExecutionCursor(value) {
+  if (!/^[A-Za-z0-9_-]+$/.test(value)) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(Buffer.from(value, "base64url").toString("utf8"));
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null) return void 0;
+  const { startedAt, executionId } = parsed;
+  if (typeof startedAt !== "number" || !Number.isFinite(startedAt)) return void 0;
+  if (typeof executionId !== "string" || executionId === "") return void 0;
+  return { startedAt, executionId };
+}
+
+// src/server/routes/executions.ts
+var DEFAULT_PAGE_LIMIT = 100;
+var MAX_PAGE_LIMIT = 500;
 function createExecutionRoutes(connMgr) {
   const app5 = new import_hono3.Hono();
   app5.get("/executions", async (c) => {
     const runtime = c.get("runtime");
-    const executions = await runtime.getExecutions();
+    const limitParam = c.req.query("limit");
+    let limit = DEFAULT_PAGE_LIMIT;
+    if (limitParam !== void 0) {
+      limit = Number(limitParam);
+      if (limitParam.trim() === "" || !Number.isInteger(limit) || limit < 1) {
+        return invalidParam("limit", `\`limit\` must be a positive integer (got "${limitParam}")`);
+      }
+      if (limit > MAX_PAGE_LIMIT) {
+        return invalidParam("limit", `\`limit\` must be at most ${MAX_PAGE_LIMIT} (got ${limit})`);
+      }
+    }
+    const cursorParam = c.req.query("cursor");
+    let cursor;
+    if (cursorParam !== void 0) {
+      cursor = decodeExecutionCursor(cursorParam);
+      if (!cursor) return invalidParam("cursor", "`cursor` is not a valid cursor");
+    }
+    const rows = await runtime.getExecutions({ limit: limit + 1, cursor });
+    const page = rows.slice(0, limit);
+    const last = page.at(-1);
+    const redact = runtime.isRedactEnabled();
     return c.json({
       ok: true,
-      data: redactExecutionList(executions, runtime.isRedactEnabled())
+      data: page.map((info) => summarizeExecution(info, redact)),
+      nextCursor: rows.length > limit && last ? encodeExecutionCursor({ startedAt: last.startedAt, executionId: last.executionId }) : null
     });
   });
+  function invalidParam(param, message) {
+    return Response.json(
+      { ok: false, error: { code: "INVALID_PARAM", message, param } },
+      { status: 400 }
+    );
+  }
   app5.get("/executions/:id", async (c) => {
     const runtime = c.get("runtime");
     const id = c.req.param("id");