@lostgradient/weft 0.13.0 → 0.15.0

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/recover-all.js

@@ -1,6 +1,5 @@
 import { z } from "zod";
 import { WorkflowTypeNotRegisteredForRecoveryError } from "../../core/engine.js";
-import { shapeRestFaultBody } from "../operation-fault.js";
 import { defineOperation } from "../operation-registry.js";
 import { shapeRestFault } from "./operation-helpers.js";
 const recoverAllInput = z.object({}), recoverAllOutput = z.object({
@@ -54,13 +53,5 @@ export const recoverAllOperation = defineOperation({
 function shapeRecoverAllFault(fault) {
   if (fault.code !== "Conflict" || fault.data.missingTypes === void 0)
     return shapeRestFault(fault);
-  return new Response(JSON.stringify({
-    ...shapeRestFaultBody(fault, "workflow_type_not_registered_for_recovery"),
-    missingTypes: fault.data.missingTypes,
-    missingWorkflowCount: fault.data.missingWorkflowCount,
-    samplesTruncated: fault.data.samplesTruncated
-  }), {
-    status: 409,
-    headers: { "Content-Type": "application/json" }
-  });
+  return shapeRestFault(fault, { message: "workflow_type_not_registered_for_recovery" });
 }

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/single-workflow-control-operation.d.ts

@@ -1,7 +1,8 @@
 import type { z } from 'zod';
 import type { Engine } from '../../core/engine.ts';
+import type { FaultCode } from '../../core/fault-code.ts';
 import type { OperationDefinition } from '../operation-catalog.ts';
-import type { FaultCode, OperationFault } from '../operation-fault.ts';
+import type { OperationFault } from '../operation-fault.ts';
 type SingleWorkflowControlInput = {
     readonly workflowId: string;
 };

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,

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

@@ -4,6 +4,11 @@ import { isAuthenticated } from "../principal.js";
 import {
   decodeCursor
 } from "../workflow-event-feed.js";
+import {
+  createReplayAwareClosableIterable,
+  workflowEventEnvelopeSchema,
+  workflowEventParameterizedAccess
+} from "./event-stream-contracts.js";
 import { invalidParamsFault } from "./operation-helpers.js";
 const INITIAL_SUBSCRIPTION_CURSOR = "-1", MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS = 1000, workflowEventsSubscriptionInput = z.object({
   workflowId: z.string().min(1),
@@ -24,30 +29,9 @@ export const workflowEventsSubscriptionOperation = defineOperation({
   inputSchema: workflowEventsSubscriptionInput,
   outputSchema: workflowEventsSubscriptionEnvelope,
   producibleFaults: ["InvalidParams"],
-  eventSchema: 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()
-  }),
+  eventSchema: workflowEventEnvelopeSchema,
   access: { kind: "authenticated" },
-  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,
   authorize: async ({ input, principal }) => {
     const requiredScope = workflowSubscriptionScope(input.selector);
     if (!isAuthenticated(principal))
@@ -71,13 +55,11 @@ export const workflowEventsSubscriptionOperation = defineOperation({
       signal: controller.signal,
       replayLimit: MAX_WORKFLOW_SUBSCRIPTION_REPLAY_EVENTS,
       createReplayLimitError: (count, limit) => invalidParamsFault(`Workflow event replay window is ${count} events; maximum is ${limit}. Supply a more recent fromCursor.`)
-    }, iterable = feed.subscribe(subscribeOptions);
+    }, iterable = createReplayAwareClosableIterable((onReplayComplete) => feed.subscribe({ ...subscribeOptions, onReplayComplete }), { close: () => controller.abort() });
     return {
       envelope: { subscriptionId: `sub_${crypto.randomUUID()}`, cursor: startingCursor },
       iterable,
-      close: async () => {
-        controller.abort();
-      }
+      close: () => iterable.close()
     };
   }
 });

package/dist/server/runtime/task-polling.js

@@ -33,8 +33,8 @@ function validateTaskResultBody(body) {
   if (status !== "completed" && status !== "failed")
     return Response.json({ error: 'status must be "completed" or "failed"' }, { status: 400 });
   const rawAttemptToken = body.attemptToken;
-  if (rawAttemptToken !== void 0 && (typeof rawAttemptToken !== "string" || rawAttemptToken === ""))
-    return Response.json({ error: "attemptToken must be a non-empty string when present" }, { status: 400 });
+  if (typeof rawAttemptToken !== "string" || rawAttemptToken === "")
+    return Response.json({ error: "attemptToken must be a non-empty string" }, { status: 400 });
   return {
     operationId,
     status,
@@ -190,7 +190,5 @@ export async function handleTaskResultRequest(context, options, request, url, pr
 function isLongPollCompletionAuthorized(inflightRecord, validated) {
   if (validated.workerId === void 0 || inflightRecord.workerId !== validated.workerId)
     return !1;
-  if (inflightRecord.attemptToken !== void 0 && validated.attemptToken !== inflightRecord.attemptToken)
-    return !1;
-  return !0;
+  return validated.attemptToken === inflightRecord.attemptToken;
 }

package/dist/server/task-state.d.ts

@@ -73,14 +73,8 @@ export interface InflightRecord extends TaskLifecycleFields {
     workflowId?: string | undefined;
     /** Durable token for the workflow run that dispatched this activity, when known. */
     workflowExecutionToken?: string | undefined;
-    /**
-     * Unique, unguessable token identifying this dispatch attempt. Rotated on every
-     * (re-)dispatch because each dispatch writes a fresh InflightRecord. The
-     * long-poll completion handler rejects a result whose echoed token does not
-     * match this value. Optional for back-compatible decoding of records written
-     * before this field existed; a missing token disables the check for that record.
-     */
-    attemptToken?: string | undefined;
+    /** Unique, unguessable token identifying this dispatch attempt. */
+    attemptToken: string;
 }
 /** Persisted record for a task in the resolved state. */
 export interface ResolvedRecord {

package/dist/server/task-state.js

@@ -1,12 +1,16 @@
 import { decode, encode } from "../core/codec.js";
 import { KEYS } from "../storage/interface.js";
 import { buildResolvedRecord } from "./task-resolved-record.js";
-export async function getTaskState(storage, operationId) {
+async function readTaskStateSnapshot(storage, operationId) {
   const [inflight, queued, resolved] = await Promise.all([
     storage.get(KEYS.operationInflight(operationId)),
     storage.get(KEYS.operationQueued(operationId)),
     storage.get(KEYS.operationResolved(operationId))
   ]);
+  return { inflight, queued, resolved };
+}
+export async function getTaskState(storage, operationId) {
+  const { inflight, queued, resolved } = await readTaskStateSnapshot(storage, operationId);
   if (inflight !== null)
     return "inflight";
   if (queued !== null)
@@ -16,11 +20,7 @@ export async function getTaskState(storage, operationId) {
   return null;
 }
 export async function getExclusiveTaskState(storage, operationId) {
-  const [inflight, queued, resolved] = await Promise.all([
-    storage.get(KEYS.operationInflight(operationId)),
-    storage.get(KEYS.operationQueued(operationId)),
-    storage.get(KEYS.operationResolved(operationId))
-  ]), states = [];
+  const { inflight, queued, resolved } = await readTaskStateSnapshot(storage, operationId), states = [];
   if (inflight !== null)
     states.push("inflight");
   if (queued !== null)
@@ -37,11 +37,14 @@ export function isQueuedRecord(value) {
   const record = value;
   return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.queuedAt === "number";
 }
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
 export function isInflightRecord(value) {
   if (value === null || typeof value !== "object")
     return !1;
   const record = value;
-  return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.workerId === "string" && typeof record.deadline === "number";
+  return typeof record.operationId === "string" && typeof record.activityName === "string" && typeof record.queue === "string" && typeof record.attempt === "number" && typeof record.visibilityTimeout === "number" && typeof record.workerId === "string" && typeof record.deadline === "number" && isNonEmptyString(record.attemptToken);
 }
 export function isResolvedRecord(value) {
   if (value === null || typeof value !== "object")

package/dist/storage/bounded-ndjson-response.d.ts

@@ -0,0 +1,5 @@
+export type BoundedNdjsonResponseOptions = {
+    readonly maximumBytes: number;
+    readonly sizeLimitError: () => Error;
+};
+export declare function readBoundedNdjsonResponse(response: Response, options: BoundedNdjsonResponseOptions): AsyncIterable<string>;