@lostgradient/weft 0.14.0 → 0.16.0

package/dist/server/operations/bulk-filter-helpers.d.ts

@@ -1,46 +1,46 @@
 import { z } from 'zod';
-import type { AttributeFilterScalarValue, BulkOperationCommitOptions, BulkOperationDryRunOptions, FailureCategory, ListFilter, SearchAttributeValue, WorkflowStatus } from '../../core/types.ts';
+import type { BulkOperationCommitOptions, BulkOperationDryRunOptions, ListFilter, WorkflowStatus } from '../../core/types.ts';
 import type { OperationFault } from '../operation-fault.ts';
 import type { Principal } from '../principal.ts';
 import type { RestInputContext } from '../rest-binding.ts';
 export declare const bulkListFilterInputSchema: 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.ZodType<WorkflowStatus, unknown, z.core.$ZodTypeInternals<WorkflowStatus, unknown>>, z.ZodArray<z.ZodType<WorkflowStatus, unknown, z.core.$ZodTypeInternals<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<SearchAttributeValue, SearchAttributeValue>>;
-        gt: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
-        lt: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
-        gte: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, AttributeFilterScalarValue>>;
-        lte: z.ZodOptional<z.ZodCustom<AttributeFilterScalarValue, 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<FailureCategory, FailureCategory>, z.ZodArray<z.ZodCustom<FailureCategory, 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>;
 export type BulkListFilterInput = z.infer<typeof bulkListFilterInputSchema>;
 export declare const bulkOperationControlInputSchema: z.ZodObject<{
     dryRun: z.ZodOptional<z.ZodBoolean>;

package/dist/server/operations/bulk-filter-helpers.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { assertScopedBulkWorkflowFilter } from "../../core/bulk-workflow-filter.js";
-import { isFailureCategory } from "../../core/failure-categories.js";
+import { listFilterObjectSchema, normalizeListFilter } from "../../core/list-filter-validation.js";
 import { coerceStartWorkflowTags } from "../../core/start-workflow-validation.js";
 import {
   MAX_BULK_CONFIRMATION_TOKEN_LENGTH,
@@ -9,38 +9,8 @@ import {
 import { readRestTextBody } from "../rest-body.js";
 import { parseOptionalFailureCategoryFilter } from "./failure-category-filter.js";
 import { invalidParamsFault, isOperationFault } from "./operation-helpers.js";
-const workflowStatusSchema = 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" || typeof entry === "number" || typeof entry === "boolean");
-}), attributeFilterScalarValueSchema = z.custom((value) => typeof value === "string" || typeof value === "number" || typeof value === "boolean"), attributeFilterSchema = z.object({
-  key: z.string().min(1),
-  value: searchAttributeValueSchema.optional(),
-  gt: attributeFilterScalarValueSchema.optional(),
-  lt: attributeFilterScalarValueSchema.optional(),
-  gte: attributeFilterScalarValueSchema.optional(),
-  lte: attributeFilterScalarValueSchema.optional()
-}), failureCategorySchema = z.custom(isFailureCategory), timeRangeSchema = z.object({
-  gte: z.number().optional(),
-  gt: z.number().optional(),
-  lte: z.number().optional(),
-  lt: z.number().optional()
-});
-export const bulkListFilterInputSchema = z.object({
-  status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).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(0).optional(),
-  offset: z.number().int().min(0).optional(),
-  idPrefix: z.string().optional(),
-  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema)]).optional(),
-  createdAt: timeRangeSchema.optional(),
-  updatedAt: timeRangeSchema.optional(),
-  executionDeadline: timeRangeSchema.optional()
+export const bulkListFilterInputSchema = listFilterObjectSchema.extend({
+  limit: z.number().int().min(0).optional()
 }), bulkOperationControlInputSchema = z.object({
   dryRun: z.boolean().optional(),
   confirmationToken: z.string().min(1).max(MAX_BULK_CONFIRMATION_TOKEN_LENGTH).optional(),
@@ -223,7 +193,7 @@ export function parseBulkListFilterFromBody(body) {
   const filterRecord = rawFilter, filter = {};
   for (const applyDimension of BULK_FILTER_DIMENSION_PARSERS)
     applyDimension(filter, filterRecord);
-  return filter;
+  return normalizeBulkListFilter(filter);
 }
 const TIME_RANGE_BOUNDS = ["gte", "gt", "lte", "lt"];
 function parseOptionalTimeRange(value) {
@@ -254,7 +224,13 @@ export function listFilterFromBulkInput(input) {
   applyBasicBulkFilterFields(filter, input);
   applyExtendedBulkFilterFields(filter, input);
   applyBulkTimeRangeFields(filter, input);
-  return filter;
+  return normalizeBulkListFilter(filter);
+}
+function normalizeBulkListFilter(filter) {
+  const limit = filter.limit;
+  delete filter.limit;
+  const normalized = normalizeListFilter(filter);
+  return limit === void 0 ? normalized : { ...normalized, limit };
 }
 function applyBasicBulkFilterFields(filter, input) {
   if (input.status !== void 0)
@@ -272,8 +248,11 @@ function applyBasicBulkFilterFields(filter, input) {
 }
 function copyAttributeFilter(attribute) {
   const filter = { key: attribute.key };
-  if (attribute.value !== void 0)
+  if (attribute.value !== void 0) {
+    if (!isJsonSearchAttributeValue(attribute.value))
+      throw Error('Field "filter.attributes[].value" must be a string, number, boolean, or scalar array');
     filter.value = attribute.value;
+  }
   if (attribute.gt !== void 0)
     filter.gt = copyAttributeRangeBound(attribute.gt, "gt");
   if (attribute.lt !== void 0)
@@ -285,7 +264,7 @@ function copyAttributeFilter(attribute) {
   return filter;
 }
 function copyAttributeRangeBound(value, property) {
-  if (Array.isArray(value))
+  if (!isJsonSearchAttributeValue(value) || Array.isArray(value))
     throw Error(`Field "filter.attributes[].${property}" must be a string, number, or boolean`);
   return value;
 }

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,14 +1,16 @@
 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 { mapScheduleErrorToFault, validateScheduleInputCadence } from "./schedule-faults.js";
-const VALID_SCHEDULE_OVERLAP_POLICIES = new Set([
-  "skip",
-  "queue",
-  "cancel-running",
-  "allow"
-]), createScheduleInput = z.object({
+import { invalidParamsFault, shapeRestFault } from "./operation-helpers.js";
+import {
+  mapScheduleErrorToFault,
+  validateScheduleInputCadence,
+  validateScheduleMutableOptions
+} from "./schedule-faults.js";
+import {
+  extractSharedScheduleRestFields,
+  parseScheduleRestBodyRequestRecord
+} from "./schedule-rest-body.js";
+const createScheduleInput = z.object({
   type: z.unknown().describe("Workflow type name. Runtime validation requires a non-empty string."),
   cronExpression: z.unknown().optional().describe("Cron expression. Supply exactly one of cronExpression or every; runtime validation requires a non-empty string."),
   every: z.unknown().optional().describe("Interval period (duration string or milliseconds). Supply exactly one of cronExpression or every."),
@@ -26,43 +28,21 @@ function validateRequiredScheduleFields(input) {
     throw invalidParamsFault("Missing required field: type");
   return { type: input.type, spec: validateScheduleInputCadence(input) };
 }
+function validateScheduleId(value) {
+  if (value === void 0)
+    return;
+  if (typeof value !== "string" || value.length === 0)
+    throw invalidParamsFault('Field "id" must be a non-empty string');
+  return value;
+}
 function validateOptionalScheduleFields(input) {
-  let validatedId;
-  if (input.id !== void 0) {
-    if (typeof input.id !== "string" || input.id.length === 0)
-      throw invalidParamsFault('Field "id" must be a non-empty string');
-    validatedId = input.id;
-  }
-  let validatedDescription;
-  if (input.description !== void 0) {
-    if (typeof input.description !== "string")
-      throw invalidParamsFault('Field "description" must be a string');
-    validatedDescription = input.description;
-  }
-  let validatedOverlap;
-  if (input.overlap !== void 0) {
-    if (typeof input.overlap !== "string" || !isScheduleOverlapPolicy(input.overlap))
-      throw invalidParamsFault('Field "overlap" must be one of skip, queue, cancel-running, allow');
-    validatedOverlap = input.overlap;
-  }
-  let validatedBackfill;
-  if (input.backfill !== void 0) {
-    if (typeof input.backfill !== "boolean")
-      throw invalidParamsFault('Field "backfill" must be a boolean');
-    validatedBackfill = input.backfill;
-  }
-  let validatedJitter;
-  if (input.jitter !== void 0) {
-    if (typeof input.jitter !== "string" && typeof input.jitter !== "number")
-      throw invalidParamsFault('Field "jitter" must be a duration string or a number of milliseconds');
-    validatedJitter = input.jitter;
-  }
+  const validatedId = validateScheduleId(input.id), validatedOptions = validateScheduleMutableOptions(input);
   return {
     id: validatedId,
-    description: validatedDescription,
-    overlap: validatedOverlap,
-    backfill: validatedBackfill,
-    jitter: validatedJitter
+    description: validatedOptions.description,
+    overlap: validatedOptions.overlap,
+    backfill: validatedOptions.backfill,
+    jitter: validatedOptions.jitter
   };
 }
 function validateCreateScheduleInput(input) {
@@ -96,11 +76,7 @@ export const createScheduleOperation = defineOperation({
       throw mapScheduleErrorToFault(validated.id ?? "", error);
     }
   }
-});
-function isScheduleOverlapPolicy(value) {
-  return VALID_SCHEDULE_OVERLAP_POLICIES.has(value);
-}
-export const createScheduleRestBinding = {
+}), createScheduleRestBinding = {
   method: "POST",
   path: "/v1/schedules",
   pathParamNames: [],
@@ -117,27 +93,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;
+}