@lostgradient/weft 0.13.0 → 0.15.0

package/dist/server/operations/bulk-mutate-workflow-tags.d.ts

@@ -3,43 +3,43 @@ import type { BulkOperationDryRunResult, BulkTagResult } from '../../core/types.
 import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const bulkMutateWorkflowTagsInput: z.ZodObject<{
     filter: z.ZodOptional<z.ZodObject<{
-        status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
+        status: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>>]>>;
         type: z.ZodOptional<z.ZodString>;
         scheduleId: z.ZodOptional<z.ZodString>;
         parentWorkflowId: z.ZodOptional<z.ZodString>;
         parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-            key: z.ZodString;
-            value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-            gt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-            lt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-            gte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-            lte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+            key: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+            value: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+            gt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+            lt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+            gte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+            lte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
         }, z.core.$strip>>>;
-        limit: z.ZodOptional<z.ZodNumber>;
         offset: z.ZodOptional<z.ZodNumber>;
         idPrefix: z.ZodOptional<z.ZodString>;
-        failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>, z.ZodArray<z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>>]>>;
         createdAt: z.ZodOptional<z.ZodObject<{
             gte: z.ZodOptional<z.ZodNumber>;
-            gt: z.ZodOptional<z.ZodNumber>;
             lte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
             lt: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
+        }, z.core.$strict>>;
         updatedAt: z.ZodOptional<z.ZodObject<{
             gte: z.ZodOptional<z.ZodNumber>;
-            gt: z.ZodOptional<z.ZodNumber>;
             lte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
             lt: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
+        }, z.core.$strict>>;
         executionDeadline: z.ZodOptional<z.ZodObject<{
             gte: z.ZodOptional<z.ZodNumber>;
-            gt: z.ZodOptional<z.ZodNumber>;
             lte: z.ZodOptional<z.ZodNumber>;
+            gt: z.ZodOptional<z.ZodNumber>;
             lt: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>;
+        }, z.core.$strict>>;
+        failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>>]>>;
+        limit: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
     tags: z.ZodArray<z.ZodString>;
     operation: z.ZodEnum<{
         add: "add";
@@ -63,35 +63,35 @@ export declare const bulkMutateWorkflowTagsOperation: import("../operation-catal
         parentWorkflowExecutionToken?: string | undefined;
         tags?: string[] | undefined;
         attributes?: {
-            key: string;
-            value?: import("../../index.ts").SearchAttributeValue | undefined;
-            gt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-            lt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-            gte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-            lte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+            key: any;
+            value?: unknown;
+            gt?: unknown;
+            lt?: unknown;
+            gte?: unknown;
+            lte?: unknown;
         }[] | undefined;
-        limit?: number | undefined;
         offset?: number | undefined;
         idPrefix?: string | undefined;
-        failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
         createdAt?: {
             gte?: number | undefined;
-            gt?: number | undefined;
             lte?: number | undefined;
+            gt?: number | undefined;
             lt?: number | undefined;
         } | undefined;
         updatedAt?: {
             gte?: number | undefined;
-            gt?: number | undefined;
             lte?: number | undefined;
+            gt?: number | undefined;
             lt?: number | undefined;
         } | undefined;
         executionDeadline?: {
             gte?: number | undefined;
-            gt?: number | undefined;
             lte?: number | undefined;
+            gt?: number | undefined;
             lt?: number | undefined;
         } | undefined;
+        failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
+        limit?: number | undefined;
     } | undefined;
     dryRun?: boolean | undefined;
     confirmationToken?: string | undefined;

package/dist/server/operations/bulk-signal-workflows.d.ts

@@ -2,42 +2,42 @@ import { z } from 'zod';
 import type { BulkOperationDryRunResult, BulkSignalResult } from '../../core/types.ts';
 import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const bulkSignalWorkflowsInput: z.ZodObject<{
-    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>, z.ZodArray<z.ZodCustom<import("../../index.ts").WorkflowStatus, import("../../index.ts").WorkflowStatus>>]>>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").WorkflowStatus, unknown, z.core.$ZodTypeInternals<import("../../index.ts").WorkflowStatus, unknown>>>]>>;
     type: z.ZodOptional<z.ZodString>;
     scheduleId: z.ZodOptional<z.ZodString>;
     parentWorkflowId: z.ZodOptional<z.ZodString>;
     parentWorkflowExecutionToken: z.ZodOptional<z.ZodString>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     attributes: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        key: z.ZodString;
-        value: z.ZodOptional<z.ZodCustom<import("../../index.ts").SearchAttributeValue, import("../../index.ts").SearchAttributeValue>>;
-        gt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-        lt: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-        gte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
-        lte: z.ZodOptional<z.ZodCustom<import("../../core/types.ts").AttributeFilterScalarValue, import("../../core/types.ts").AttributeFilterScalarValue>>;
+        key: z.ZodUnion<readonly [z.ZodString, z.ZodAny]>;
+        value: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        gt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        lt: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        gte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+        lte: z.ZodOptional<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
     }, z.core.$strip>>>;
-    limit: z.ZodOptional<z.ZodNumber>;
     offset: z.ZodOptional<z.ZodNumber>;
     idPrefix: z.ZodOptional<z.ZodString>;
-    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>, z.ZodArray<z.ZodCustom<import("../../index.ts").FailureCategory, import("../../index.ts").FailureCategory>>]>>;
     createdAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     updatedAt: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
     executionDeadline: z.ZodOptional<z.ZodObject<{
         gte: z.ZodOptional<z.ZodNumber>;
-        gt: z.ZodOptional<z.ZodNumber>;
         lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
         lt: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
+    }, z.core.$strict>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>, z.ZodArray<z.ZodType<import("../../index.ts").FailureCategory, unknown, z.core.$ZodTypeInternals<import("../../index.ts").FailureCategory, unknown>>>]>>;
+    limit: z.ZodOptional<z.ZodNumber>;
     name: z.ZodString;
     payload: z.ZodOptional<z.ZodUnknown>;
     dryRun: z.ZodOptional<z.ZodBoolean>;
@@ -56,35 +56,35 @@ export declare const bulkSignalWorkflowsOperation: import("../operation-catalog.
     parentWorkflowExecutionToken?: string | undefined;
     tags?: string[] | undefined;
     attributes?: {
-        key: string;
-        value?: import("../../index.ts").SearchAttributeValue | undefined;
-        gt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-        lt?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-        gte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
-        lte?: import("../../core/types.ts").AttributeFilterScalarValue | undefined;
+        key: any;
+        value?: unknown;
+        gt?: unknown;
+        lt?: unknown;
+        gte?: unknown;
+        lte?: unknown;
     }[] | undefined;
-    limit?: number | undefined;
     offset?: number | undefined;
     idPrefix?: string | undefined;
-    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
     createdAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     updatedAt?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
     executionDeadline?: {
         gte?: number | undefined;
-        gt?: number | undefined;
         lte?: number | undefined;
+        gt?: number | undefined;
         lt?: number | undefined;
     } | undefined;
+    failureCategory?: import("../../index.ts").FailureCategory | import("../../index.ts").FailureCategory[] | undefined;
+    limit?: number | undefined;
     payload?: unknown;
     dryRun?: boolean | undefined;
     confirmationToken?: string | undefined;

package/dist/server/operations/create-schedule.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
 import { defineOperation } from "../operation-registry.js";
-import { readRestJsonBody } from "../rest-body.js";
-import { invalidParamsFault, isOperationFault, shapeRestFault } from "./operation-helpers.js";
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
+import {
+  extractSharedScheduleRestFields,
+  parseScheduleRestBodyRequestRecord
+} from "./schedule-rest-body.js";
 const VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
   "skip",
   "queue",
@@ -117,27 +120,12 @@ export const createScheduleRestBinding = {
     jitter: { kind: "body-field", bodyField: "jitter" }
   },
   extractInput: async (request, _pathParams, context) => {
-    let body;
-    try {
-      body = await readRestJsonBody(request, context);
-    } catch (error) {
-      if (isOperationFault(error))
-        throw error;
-      throw invalidParamsFault("Invalid JSON body");
-    }
-    if (typeof body !== "object" || body === null)
-      throw invalidParamsFault("Request body must be a JSON object");
-    const record = body;
+    const record = await parseScheduleRestBodyRequestRecord(request, context);
     return {
       type: record.type,
-      cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
-      every: Object.hasOwn(record, "every") ? record.every : void 0,
       input: record.input,
       id: record.id,
-      description: record.description,
-      overlap: record.overlap,
-      backfill: record.backfill,
-      jitter: record.jitter
+      ...extractSharedScheduleRestFields(record)
     };
   },
   success: { kind: "json", status: 201 },

package/dist/server/operations/event-stream-contracts.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import type { FleetEventEnvelope } from '../fleet-event-feed.ts';
+import type { ParameterizedAccessHint } from '../operation-catalog/types.ts';
+import type { EventEnvelope } from '../workflow-event-feed.ts';
+export declare const fleetEventEnvelopeSchema: z.ZodType<FleetEventEnvelope>;
+export declare const workflowEventEnvelopeSchema: z.ZodType<EventEnvelope>;
+export declare const workflowEventParameterizedAccess: ParameterizedAccessHint;
+export type ClosableAsyncIterable<T> = AsyncIterable<T> & {
+    close(): Promise<void>;
+};
+export type ReplayAwareClosableIterable<T> = ClosableAsyncIterable<T> & {
+    readonly replayComplete: Promise<void>;
+};
+type ReplayAwareClosableIterableOptions = {
+    readonly close: () => void | Promise<void>;
+};
+export declare function createReplayAwareClosableIterable<T>(createSource: (onReplayComplete: () => void) => AsyncIterable<T>, options: ReplayAwareClosableIterableOptions): ReplayAwareClosableIterable<T>;
+export declare function isClosableAsyncIterable<T>(value: unknown): value is ClosableAsyncIterable<T>;
+export declare function isReplayAwareClosableIterable<T>(value: unknown): value is ReplayAwareClosableIterable<T>;
+export {};

package/dist/server/operations/event-stream-contracts.js

@@ -0,0 +1,67 @@
+import { z } from "zod";
+export const fleetEventEnvelopeSchema = z.object({
+  kind: z.string(),
+  workflowId: z.string().optional(),
+  sequence: z.number(),
+  cursor: z.string(),
+  emittedAtMs: z.number(),
+  payload: z.unknown()
+}), workflowEventEnvelopeSchema = z.object({
+  kind: z.string(),
+  workflowId: z.string(),
+  selector: z.enum(["events", "tokens"]),
+  sequence: z.number(),
+  cursor: z.string(),
+  emittedAtMs: z.number(),
+  payload: z.unknown()
+}), workflowEventParameterizedAccess = {
+  discriminator: "selector",
+  defaultValue: "events",
+  variants: [
+    {
+      value: "events",
+      access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["events:read"] } }
+    },
+    {
+      value: "tokens",
+      access: { kind: "scoped", scopes: { kind: "anyOf", scopes: ["streams:read"] } }
+    }
+  ]
+};
+export function createReplayAwareClosableIterable(createSource, options) {
+  const replayComplete = Promise.withResolvers();
+  let closePromise;
+  const close = () => {
+    if (closePromise !== void 0)
+      return closePromise;
+    closePromise = Promise.resolve().then(options.close);
+    return closePromise;
+  };
+  let source;
+  try {
+    source = createSource(() => replayComplete.resolve());
+  } catch (error) {
+    close();
+    throw error;
+  }
+  return {
+    async* [Symbol.asyncIterator]() {
+      try {
+        for await (const value of source)
+          yield value;
+      } finally {
+        await close();
+      }
+    },
+    replayComplete: replayComplete.promise,
+    close
+  };
+}
+export function isClosableAsyncIterable(value) {
+  if (typeof value !== "object" || value === null)
+    return !1;
+  return typeof value.close === "function";
+}
+export function isReplayAwareClosableIterable(value) {
+  return isClosableAsyncIterable(value) && "replayComplete" in value && value.replayComplete instanceof Promise;
+}

package/dist/server/operations/fleet-events-sse.js

@@ -4,6 +4,12 @@ import { EVENTS_READ_EVENT_TYPES } from "../runtime/client-visible-events.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  fleetEventEnvelopeSchema,
+  isClosableAsyncIterable,
+  isReplayAwareClosableIterable
+} from "./event-stream-contracts.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 import {
   createEventEnvelopeSSEStream,
@@ -19,14 +25,7 @@ const INITIAL_CURSOR = "-1", MAX_FLEET_SSE_REPLAY_EVENTS = 1000, cursorSchema =
   kind: fleetEventKindSchema.optional(),
   fromCursor: cursorSchema.optional(),
   lastEventId: cursorSchema.optional()
-}), fleetEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable fleet event stream"), fleetEventEnvelopeSchema = z.object({
-  kind: z.string(),
-  workflowId: z.string().optional(),
-  sequence: z.number(),
-  cursor: z.string(),
-  emittedAtMs: z.number(),
-  payload: z.unknown()
-});
+}), fleetEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable fleet event stream");
 export const fleetEventsSseOperation = defineOperation({
   name: "weft.events.sse",
   mcpExposable: !1,
@@ -67,12 +66,6 @@ function isAsyncIterable(value) {
     return !1;
   return typeof value[Symbol.asyncIterator] === "function";
 }
-function isClosableFleetEventsIterable(value) {
-  return "close" in value && typeof value.close === "function";
-}
-function isReplayAwareFleetEventsIterable(value) {
-  return isClosableFleetEventsIterable(value) && "replayComplete" in value && value.replayComplete instanceof Promise;
-}
 function matchesFleetEventFilter(envelope, input) {
   if (input.workflowId !== void 0 && envelope.workflowId !== input.workflowId)
     return !1;
@@ -84,49 +77,27 @@ function createFleetEventsIterable(input, context) {
   const feed = context.fleetEventFeed;
   if (feed === void 0)
     throw unsupportedEventStreamContextFault("fleet event SSE requires a fleet event feed");
-  const controller = new AbortController, replayComplete = Promise.withResolvers();
-  let closed = !1;
-  const close = async () => {
-    if (closed)
-      return;
-    closed = !0;
-    controller.abort();
-  }, subscribeOptions = {
-    fromCursor: input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR,
-    signal: controller.signal,
-    replayLimit: MAX_FLEET_SSE_REPLAY_EVENTS,
-    filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
-    onReplayComplete: () => replayComplete.resolve(),
-    createReplayLimitError: (count, limit) => invalidParamsFault(`Fleet event replay window is ${count} matching events; maximum is ${limit}. Supply a more recent fromCursor.`)
-  };
-  let source;
-  try {
-    source = feed.subscribe(subscribeOptions);
-  } catch (error) {
-    close();
-    throw error;
-  }
-  return {
-    async* [Symbol.asyncIterator]() {
-      try {
-        for await (const envelope of source)
-          yield envelope;
-      } finally {
-        await close();
-      }
-    },
-    replayComplete: replayComplete.promise,
-    close
-  };
+  const controller = new AbortController, fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR;
+  return createReplayAwareClosableIterable((onReplayComplete) => {
+    const subscribeOptions = {
+      fromCursor,
+      signal: controller.signal,
+      replayLimit: MAX_FLEET_SSE_REPLAY_EVENTS,
+      filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
+      onReplayComplete,
+      createReplayLimitError: (count, limit) => invalidParamsFault(`Fleet event replay window is ${count} matching events; maximum is ${limit}. Supply a more recent fromCursor.`)
+    };
+    return feed.subscribe(subscribeOptions);
+  }, { close: () => controller.abort() });
 }
 function shapeFleetEventsSseSuccess(output, request) {
-  const close = isClosableFleetEventsIterable(output) ? () => output.close() : async () => {
+  const close = isClosableAsyncIterable(output) ? () => output.close() : async () => {
     return;
   };
   return new Response(createEventEnvelopeSSEStream({
     iterable: output,
     close,
-    ...isReplayAwareFleetEventsIterable(output) ? { ready: output.replayComplete } : {},
+    ...isReplayAwareClosableIterable(output) ? { ready: output.replayComplete } : {},
     signal: request.signal
   }), {
     status: 200,

package/dist/server/operations/fleet-events-subscription.js

@@ -3,6 +3,10 @@ import { raiseFault } from "../operation-catalog/raise-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { EVENTS_READ_EVENT_TYPES } from "../runtime/client-visible-events.js";
 import { decodeCursor } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  fleetEventEnvelopeSchema
+} from "./event-stream-contracts.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS = 1000, fleetEventKindSchema = z.enum(EVENTS_READ_EVENT_TYPES), fleetCursorSchema = z.string().regex(/^(?:-1|\d+)$/, "Invalid cursor").refine((cursor) => decodeCursor(cursor) !== null, {
   message: "Invalid cursor"
@@ -13,13 +17,6 @@ const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS =
 }), fleetEventsSubscriptionEnvelope = z.object({
   subscriptionId: z.string(),
   cursor: z.string()
-}), fleetEventEnvelopeSchema = z.object({
-  kind: z.string(),
-  workflowId: z.string().optional(),
-  sequence: z.number(),
-  cursor: z.string(),
-  emittedAtMs: z.number(),
-  payload: z.unknown()
 });
 export const fleetEventsSubscriptionOperation = defineOperation({
   name: "weft.events.subscribe",
@@ -44,19 +41,18 @@ export const fleetEventsSubscriptionOperation = defineOperation({
     const startingCursor = input.fromCursor ?? INITIAL_SUBSCRIPTION_CURSOR;
     if (decodeCursor(startingCursor) === null)
       raiseFault(fleetEventsSubscriptionOperation, invalidParamsFault("Invalid cursor"));
-    const fleetFeed = getFleetEventFeed(engine, transport), controller = new AbortController, iterable = fleetFeed.subscribe({
+    const fleetFeed = getFleetEventFeed(engine, transport), controller = new AbortController, iterable = createReplayAwareClosableIterable((onReplayComplete) => fleetFeed.subscribe({
       ...input.fromCursor === void 0 ? {} : { fromCursor: input.fromCursor },
       signal: controller.signal,
       replayLimit: MAX_FLEET_SUBSCRIPTION_REPLAY_EVENTS,
       filterEnvelope: (envelope) => matchesFleetEventFilter(envelope, input),
+      onReplayComplete,
       createReplayLimitError: (count, limit) => fleetReplayLimitFault(count, limit)
-    });
+    }), { close: () => controller.abort() });
     return {
       envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
       iterable,
-      close: async () => {
-        controller.abort();
-      }
+      close: () => iterable.close()
     };
   }
 });

package/dist/server/operations/list-reviews.js

@@ -1,29 +1,12 @@
 import { z } from "zod";
+import { reviewListEntrySchema } from "../../core/review/index.js";
 import { shapeOperationFaultAsJson } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 const reviewStatusSchema = z.enum(["pending", "completed"]), listReviewsInput = z.object({
   status: reviewStatusSchema.optional(),
   workflowId: z.string().min(1).optional(),
   reviewType: z.string().min(1).optional()
-}), pendingReviewEntrySchema = z.object({
-  status: z.literal("pending"),
-  reviewId: z.string(),
-  workflowId: z.string(),
-  artifact: z.unknown().nonoptional(),
-  reviewType: z.string(),
-  reviewers: z.array(z.string()),
-  allowPartial: z.boolean(),
-  timeout: z.number().optional(),
-  webhookUrl: z.string().optional(),
-  createdAt: z.number()
-}), completedReviewEntrySchema = pendingReviewEntrySchema.extend({
-  status: z.literal("completed"),
-  decision: z.enum(["approved", "rejected", "needs-changes"]),
-  reviewer: z.string(),
-  feedback: z.string().optional(),
-  sectionDecisions: z.record(z.string(), z.enum(["approved", "rejected"])).optional(),
-  timestamp: z.number()
-}), reviewListEntrySchema = z.union([pendingReviewEntrySchema, completedReviewEntrySchema]), listReviewsOutput = z.object({
+}), listReviewsOutput = z.object({
   items: z.array(reviewListEntrySchema)
 });
 export const listReviewsOperation = defineOperation({