@lostgradient/weft 0.14.0 → 0.15.0

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-workflows.d.ts

@@ -1,85 +1,85 @@
 import { z } from 'zod';
-import type { FailureCategory, PaginatedResult, SearchAttributeValue, WorkflowStatus, WorkflowSummary } from '../../core/types.ts';
+import type { PaginatedResult, WorkflowSummary } from '../../core/types.ts';
 import type { UnknownRestBinding } from '../rest-bindings.ts';
 declare const listWorkflowsInput: z.ZodObject<{
-    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<WorkflowStatus, WorkflowStatus>, z.ZodArray<z.ZodCustom<WorkflowStatus, WorkflowStatus>>]>>;
+    status: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     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<SearchAttributeValue, SearchAttributeValue>>;
-        gt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        lt: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        gte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-        lte: z.ZodOptional<z.ZodCustom<SearchAttributeValue, SearchAttributeValue>>;
-    }, z.core.$strip>>>;
-    limit: z.ZodOptional<z.ZodNumber>;
-    offset: z.ZodOptional<z.ZodNumber>;
     idPrefix: z.ZodOptional<z.ZodString>;
     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>>;
-    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<FailureCategory, FailureCategory>, z.ZodArray<z.ZodCustom<FailureCategory, FailureCategory>>]>>;
+    }, z.core.$strict>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     include: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
-}, z.core.$strip>;
+    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.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>;
+}, z.core.$strict>;
 export type ListWorkflowsInput = z.infer<typeof listWorkflowsInput>;
 export type ListWorkflowsOutput = PaginatedResult<WorkflowSummary>;
 export declare const listWorkflowsOperation: import("../operation-catalog.ts").OperationDefinition<{
-    status?: WorkflowStatus | WorkflowStatus[] | undefined;
+    status?: string | string[] | undefined;
     type?: string | undefined;
-    scheduleId?: string | undefined;
-    parentWorkflowId?: string | undefined;
-    parentWorkflowExecutionToken?: string | undefined;
-    tags?: string[] | undefined;
-    attributes?: {
-        key: string;
-        value?: SearchAttributeValue | undefined;
-        gt?: SearchAttributeValue | undefined;
-        lt?: SearchAttributeValue | undefined;
-        gte?: SearchAttributeValue | undefined;
-        lte?: SearchAttributeValue | undefined;
-    }[] | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
     idPrefix?: string | 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?: FailureCategory | FailureCategory[] | undefined;
+    failureCategory?: string | string[] | undefined;
     include?: string | string[] | undefined;
+    scheduleId?: string | undefined;
+    parentWorkflowId?: string | undefined;
+    parentWorkflowExecutionToken?: string | undefined;
+    tags?: string[] | undefined;
+    attributes?: {
+        key: any;
+        value?: unknown;
+        gt?: unknown;
+        lt?: unknown;
+        gte?: unknown;
+        lte?: unknown;
+    }[] | undefined;
+    limit?: number | undefined;
+    offset?: number | undefined;
 }, ListWorkflowsOutput, unknown>;
 export declare const listWorkflowsRestBinding: UnknownRestBinding;
 export {};

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

@@ -2,45 +2,24 @@ import { z } from "zod";
 import { WorkflowListScanCapExceededError } from "../../core/engine/workflow-indexes.js";
 import {
   ListFilterValidationError,
+  listFilterObjectSchema,
   normalizeListFilter
 } from "../../core/list-filter-validation.js";
 import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
 import { defineOperation } from "../operation-registry.js";
 import { extractListFilterFromQuery } from "./list-filter-query-extractor.js";
 import { shapeRestFault } from "./operation-helpers.js";
-const workflowStatusSchema = z.custom((value) => typeof value === "string"), failureCategorySchema = z.custom((value) => typeof value === "string"), searchAttributeValueSchema = z.custom((value) => {
-  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean")
-    return !0;
-  return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}), attributeFilterSchema = z.object({
-  key: z.string().min(1),
-  value: searchAttributeValueSchema.optional(),
-  gt: searchAttributeValueSchema.optional(),
-  lt: searchAttributeValueSchema.optional(),
-  gte: searchAttributeValueSchema.optional(),
-  lte: searchAttributeValueSchema.optional()
-}), timeRangeSchema = z.object({
-  gte: z.number().optional(),
-  gt: z.number().optional(),
-  lte: z.number().optional(),
-  lt: z.number().optional()
-}), listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
-  status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
+const listIncludeSchema = z.union([z.string(), z.array(z.string()).min(1)]).refine((value) => Array.isArray(value) ? value.every((entry) => entry === "failureCategory") : value === "failureCategory", { message: 'include must be "failureCategory"' }), listWorkflowsInput = z.object({
+  ...listFilterObjectSchema.shape,
+  status: z.union([z.string(), z.array(z.string())]).optional(),
   type: z.string().optional(),
-  scheduleId: z.string().min(1).optional(),
-  parentWorkflowId: z.string().min(1).optional(),
-  parentWorkflowExecutionToken: z.string().min(1).optional(),
-  tags: z.array(z.string()).optional(),
-  attributes: z.array(attributeFilterSchema).optional(),
-  limit: z.number().int().min(1).max(1000).optional(),
-  offset: z.number().int().min(0).optional(),
   idPrefix: z.string().optional(),
-  createdAt: timeRangeSchema.optional(),
-  updatedAt: timeRangeSchema.optional(),
-  executionDeadline: timeRangeSchema.optional(),
-  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema)]).optional(),
+  createdAt: z.object(listFilterObjectSchema.shape.createdAt.unwrap().shape).strict().optional(),
+  updatedAt: z.object(listFilterObjectSchema.shape.updatedAt.unwrap().shape).strict().optional(),
+  executionDeadline: z.object(listFilterObjectSchema.shape.executionDeadline.unwrap().shape).strict().optional(),
+  failureCategory: z.union([z.string(), z.array(z.string())]).optional(),
   include: listIncludeSchema.optional()
-}), listWorkflowsOutput = z.unknown();
+}).strict(), listWorkflowsOutput = z.unknown();
 export const listWorkflowsOperation = defineOperation({
   name: "weft.workflows.list",
   mcpExposable: !1,

package/dist/server/operations/purge-workflows.d.ts

@@ -11,34 +11,34 @@ export declare const purgeWorkflowsOperation: import("../operation-catalog.ts").
     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;
 }, PurgeResult, unknown>;
 export declare const purgeWorkflowsRestBinding: UnknownRestBinding;

package/dist/server/operations/schedule-rest-body.d.ts

@@ -0,0 +1,11 @@
+import type { RestInputContext } from '../rest-binding.ts';
+export type SharedScheduleRestFields = {
+    readonly cronExpression: unknown;
+    readonly every: unknown;
+    readonly description: unknown;
+    readonly overlap: unknown;
+    readonly backfill: unknown;
+    readonly jitter: unknown;
+};
+export declare function parseScheduleRestBodyRequestRecord(request: Request, context?: RestInputContext): Promise<Record<string, unknown>>;
+export declare function extractSharedScheduleRestFields(record: Record<string, unknown>): SharedScheduleRestFields;

package/dist/server/operations/schedule-rest-body.js

@@ -0,0 +1,28 @@
+import { readRestJsonBody } from "../rest-body.js";
+import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
+function isJsonObjectLikeRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+export async function parseScheduleRestBodyRequestRecord(request, context) {
+  let body;
+  try {
+    body = await readRestJsonBody(request, context);
+  } catch (error) {
+    if (isOperationFault(error))
+      throw error;
+    throw invalidParamsFault("Invalid JSON body");
+  }
+  if (!isJsonObjectLikeRecord(body))
+    throw invalidParamsFault("Request body must be a JSON object");
+  return body;
+}
+export function extractSharedScheduleRestFields(record) {
+  return {
+    cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
+    every: Object.hasOwn(record, "every") ? record.every : void 0,
+    description: record.description,
+    overlap: record.overlap,
+    backfill: record.backfill,
+    jitter: record.jitter
+  };
+}

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

@@ -1,9 +1,12 @@
 import { z } from "zod";
 import { normalizeScheduleUpdateOptions } from "../../core/engine/validation/schedule.js";
 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 updateScheduleInput = z.object({
   scheduleId: z.string().min(1),
   cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
@@ -100,25 +103,10 @@ export const updateScheduleOperation = defineOperation({
     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 {
       scheduleId: pathParams.id ?? "",
-      cronExpression: Object.hasOwn(record, "cronExpression") ? record.cronExpression : void 0,
-      every: Object.hasOwn(record, "every") ? record.every : void 0,
-      description: record.description,
-      overlap: record.overlap,
-      backfill: record.backfill,
-      jitter: record.jitter
+      ...extractSharedScheduleRestFields(record)
     };
   },
   success: { kind: "empty", status: 204 },

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

@@ -4,6 +4,13 @@ import { isAuthenticated } from "../principal.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  isClosableAsyncIterable,
+  isReplayAwareClosableIterable,
+  workflowEventEnvelopeSchema,
+  workflowEventParameterizedAccess
+} from "./event-stream-contracts.js";
 import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
 import {
   createEventEnvelopeSSEStream,
@@ -19,15 +26,7 @@ const INITIAL_CURSOR = "-1", MAX_WORKFLOW_SSE_REPLAY_EVENTS = 1000, MAXIMUM_WORK
   selector: z.enum(["events", "tokens"]).default("events"),
   fromCursor: cursorSchema.optional(),
   lastEventId: cursorSchema.optional()
-}), workflowEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable workflow event stream"), 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()
-});
+}), workflowEventsSseOutputSchema = z.custom(isAsyncIterable, "Expected async iterable workflow event stream");
 export const workflowEventsSseOperation = defineOperation({
   name: "weft.workflows.events.sse",
   mcpExposable: !1,
@@ -39,20 +38,7 @@ export const workflowEventsSseOperation = defineOperation({
   inputSchema: workflowEventsSseInputSchema,
   outputSchema: workflowEventsSseOutputSchema,
   eventSchema: workflowEventEnvelopeSchema,
-  parameterizedAccess: {
-    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"] } }
-      }
-    ]
-  },
+  parameterizedAccess: workflowEventParameterizedAccess,
   producibleFaults: ["InvalidParams", "UnsupportedTransport"],
   access: { kind: "authenticated" },
   authorize: async ({ input, principal }) => {
@@ -97,12 +83,6 @@ function isAsyncIterable(value) {
     return !1;
   return typeof value[Symbol.asyncIterator] === "function";
 }
-function isClosableWorkflowEventsIterable(value) {
-  return "close" in value && typeof value.close === "function";
-}
-function isReplayAwareWorkflowEventsIterable(value) {
-  return isClosableWorkflowEventsIterable(value) && "replayComplete" in value && value.replayComplete instanceof Promise;
-}
 function createWorkflowEventsIterable(input, context) {
   const feed = context.workflowEventFeed;
   if (feed === void 0)
@@ -110,51 +90,33 @@ function createWorkflowEventsIterable(input, context) {
   const lease = context.acquireWorkflowStreamConnection?.(input.workflowId);
   if (lease === null)
     throw maximumWorkflowStreamsFault();
-  const controller = new AbortController, replayComplete = Promise.withResolvers();
-  let closed = !1;
-  const close = async () => {
-    if (closed)
-      return;
-    closed = !0;
-    controller.abort();
-    lease?.release();
-  }, fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR, subscribeOptions = {
-    workflowId: input.workflowId,
-    selector: input.selector,
-    fromCursor,
-    signal: controller.signal,
-    replayLimit: MAX_WORKFLOW_SSE_REPLAY_EVENTS,
-    onReplayComplete: () => replayComplete.resolve(),
-    createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} 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 fromCursor = input.lastEventId ?? input.fromCursor ?? INITIAL_CURSOR, controller = new AbortController;
+  return createReplayAwareClosableIterable((onReplayComplete) => {
+    const subscribeOptions = {
+      workflowId: input.workflowId,
+      selector: input.selector,
+      fromCursor,
+      signal: controller.signal,
+      replayLimit: MAX_WORKFLOW_SSE_REPLAY_EVENTS,
+      onReplayComplete,
+      createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
+    };
+    return feed.subscribe(subscribeOptions);
+  }, {
+    close: () => {
+      controller.abort();
+      lease?.release();
+    }
+  });
 }
 function shapeWorkflowEventsSseSuccess(output, request) {
-  const close = isClosableWorkflowEventsIterable(output) ? () => output.close() : async () => {
+  const close = isClosableAsyncIterable(output) ? () => output.close() : async () => {
     return;
   };
   return new Response(createEventEnvelopeSSEStream({
     iterable: output,
     close,
-    ...isReplayAwareWorkflowEventsIterable(output) ? { ready: output.replayComplete } : {},
+    ...isReplayAwareClosableIterable(output) ? { ready: output.replayComplete } : {},
     signal: request.signal
   }), {
     status: 200,