@lostgradient/weft 0.14.0 → 0.15.0

package/dist/server/operation-registry.d.ts

@@ -17,9 +17,7 @@
  *     cast required at the registry boundary.
  */
 import type { z } from 'zod';
-import type { FaultCode } from '../core/fault-code.ts';
-import type { AccessPolicy } from './authorization.ts';
-import type { AuthorizationDecision, McpToolMetadata, OperationContext, OperationDefinition, OperationInvocationResult, ParameterizedAccessHint, TransportAvailability, UnknownKeyPolicy } from './operation-catalog/types.ts';
+import type { OperationDefinition, OperationDefinitionBase } from './operation-catalog/types.ts';
 export { isValidOperationName, validateOperationName } from './operation-catalog.ts';
 /**
  * Input shape for `defineOperation`. Mirrors `OperationDefinition` but
@@ -31,35 +29,8 @@ export { isValidOperationName, validateOperationName } from './operation-catalog
  * passes. When present, BOTH `access` AND `authorize` must permit the
  * call: the policy runs first, then the parameter-aware hook.
  */
-type OperationDefinitionInputBase<Input, Output, Element = unknown> = {
-    readonly name: string;
-    readonly mcpExposable: boolean;
-    readonly mcpTool?: McpToolMetadata;
-    readonly summary: string;
-    /**
-     * Optional longer-form prose. See {@link OperationDefinition} for the
-     * contract and the surfaces (OpenAPI, OpenRPC, CLI `--describe`, MCP
-     * discovery) that read it. `summary` stays mandatory and short.
-     */
-    readonly description?: string;
+type OperationDefinitionInputBase<Input, Output, Element = unknown> = Omit<OperationDefinitionBase<Input, Output, Element>, 'tags'> & {
     readonly tags?: ReadonlyArray<string>;
-    /**
-     * Whether invoking this operation irreversibly mutates state. Required —
-     * there is deliberately no default, so every operation author must make
-     * the call explicitly. See {@link OperationDefinition} for the contract
-     * and the consumers that read it.
-     */
-    readonly destructive: boolean;
-    readonly inputSchema: z.ZodType<Input>;
-    readonly outputSchema: z.ZodType<Output>;
-    readonly access: AccessPolicy;
-    readonly parameterizedAccess?: ParameterizedAccessHint;
-    readonly producibleFaults?: ReadonlyArray<FaultCode>;
-    readonly discoverable?: boolean;
-    readonly transports: TransportAvailability;
-    readonly unknownKeyPolicy: UnknownKeyPolicy;
-    readonly authorize?: (context: OperationContext<Input>) => Promise<AuthorizationDecision>;
-    readonly invoke: (context: OperationContext<Input>) => Promise<OperationInvocationResult<Output, Element>>;
 };
 /**
  * Discriminated input for `defineOperation`, mirroring the discriminated

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,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;
+}