@lostgradient/weft 0.2.0

package/dist/core/interceptor/interceptor-interfaces.d.ts

@@ -0,0 +1,149 @@
+import type { ActivityExecutionInterception, ActivityInterception, ChildWorkflowInterception, QueryInterception, SignalInterception, SignalReceivedInterception, SleepInterception, WorkflowStartInterception } from './interception-contexts.ts';
+/**
+ * Middleware interface for workflow-side interception. Each hook is optional
+ * — implement only the hooks you need. Hooks are generator functions that
+ * receive an interception context and a `next` callback; call `yield* next(ctx)`
+ * to pass control to the next interceptor in the chain.
+ *
+ * @example
+ * ```ts
+ * import { workflow, Engine, type WorkflowInterceptor } from '@lostgradient/weft';
+ *
+ * const tracer: WorkflowInterceptor = {
+ *   *activity(ctx, next) {
+ *     console.log('activity started:', ctx.activityName);
+ *     const result = yield* next(ctx);
+ *     console.log('activity done:', ctx.activityName);
+ *     return result;
+ *   },
+ * };
+ *
+ * const engine = new Engine();
+ * engine.register(workflow({ name: 'ping' }).execute(async function* () { return 'pong'; }));
+ * void engine;
+ * void tracer;
+ * ```
+ */
+export interface WorkflowInterceptor {
+    activity?(interception: ActivityInterception, next: (interception: ActivityInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    sleep?(interception: SleepInterception, next: (interception: SleepInterception) => Generator<unknown, void, unknown>): Generator<unknown, void, unknown>;
+    waitForSignal?(interception: SignalInterception, next: (interception: SignalInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    workflowStart?(interception: WorkflowStartInterception, next: (interception: WorkflowStartInterception) => void): void;
+    childWorkflow?(interception: ChildWorkflowInterception, next: (interception: ChildWorkflowInterception) => Promise<unknown>): Promise<unknown>;
+    query?(interception: QueryInterception, next: (interception: QueryInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    signalReceived?(interception: SignalReceivedInterception, next: (interception: SignalReceivedInterception) => void): void;
+}
+/**
+ * Internal: the canonical list of workflow-side hook names. Used by
+ * {@link splitInterceptors} to route a unified `Interceptor` instance into
+ * the workflow-side pipeline. Frozen so consumers (and we) cannot mutate
+ * the array at runtime — the type system already marks it readonly, but
+ * the runtime array would otherwise be mutable.
+ *
+ * Not exported from the package root: this is an implementation detail.
+ * The `interceptor-types.test.ts` exhaustiveness assertions guarantee
+ * this stays in sync with `WorkflowInterceptor`.
+ */
+export declare const WORKFLOW_INTERCEPTOR_HOOKS: readonly ["activity", "sleep", "waitForSignal", "workflowStart", "childWorkflow", "query", "signalReceived"];
+/**
+ * Middleware interface for activity-execution interception. Runs on the
+ * side that actually executes the activity function (main thread or worker).
+ * Implement `execute` to add retry logging, tracing, or input/output transforms.
+ *
+ * @example
+ * ```ts
+ * import { Engine, type ActivityInterceptor } from '@lostgradient/weft';
+ *
+ * const logger: ActivityInterceptor = {
+ *   async execute(ctx, next) {
+ *     const result = await next(ctx);
+ *     console.log(ctx.activityName, 'attempt', ctx.attempt, 'succeeded');
+ *     return result;
+ *   },
+ * };
+ * void logger;
+ * ```
+ */
+export interface ActivityInterceptor {
+    execute?(interception: ActivityExecutionInterception, next: (interception: ActivityExecutionInterception) => Promise<unknown>): Promise<unknown>;
+}
+/**
+ * Unified interceptor surface accepted by the engine. Implement hooks from
+ * either the workflow side, the activity side, or both; each interceptor
+ * participates in whichever pipeline has matching hooks.
+ *
+ * @example
+ * ```ts
+ * import { Engine, type Interceptor } from '@lostgradient/weft';
+ *
+ * const tracer: Interceptor = {
+ *   *activity(interception, next) {
+ *     return yield* next(interception);
+ *   },
+ *   async execute(interception, next) {
+ *     return next(interception);
+ *   },
+ * };
+ *
+ * const engine = new Engine({ interceptors: [tracer] });
+ * void engine;
+ * ```
+ */
+export interface Interceptor extends WorkflowInterceptor, ActivityInterceptor {
+}
+/**
+ * The fully-composed workflow interceptor produced by
+ * {@link composeWorkflowInterceptors}. All hooks are non-optional — the
+ * composition fills in pass-through implementations for any hooks not
+ * provided by the individual interceptors. Used internally by the engine.
+ *
+ * @example
+ * ```ts
+ * import { composeWorkflowInterceptors, type ComposedWorkflowInterceptor } from '@lostgradient/weft';
+ * import type { WorkflowInterceptor } from '@lostgradient/weft';
+ *
+ * const tracer: WorkflowInterceptor = {
+ *   *activity(ctx, next) {
+ *     console.log('activity:', ctx.activityName);
+ *     return yield* next(ctx);
+ *   },
+ * };
+ *
+ * const composed: ComposedWorkflowInterceptor = composeWorkflowInterceptors([tracer]);
+ * void composed;
+ * ```
+ */
+export interface ComposedWorkflowInterceptor {
+    activity(interception: ActivityInterception, execute: (interception: ActivityInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    sleep(interception: SleepInterception, execute: (interception: SleepInterception) => Generator<unknown, void, unknown>): Generator<unknown, void, unknown>;
+    waitForSignal(interception: SignalInterception, execute: (interception: SignalInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    workflowStart(interception: WorkflowStartInterception, execute: (interception: WorkflowStartInterception) => void): void;
+    childWorkflow(interception: ChildWorkflowInterception, execute: (interception: ChildWorkflowInterception) => Promise<unknown>): Promise<unknown>;
+    query(interception: QueryInterception, execute: (interception: QueryInterception) => Generator<unknown, unknown, unknown>): Generator<unknown, unknown, unknown>;
+    signalReceived(interception: SignalReceivedInterception, execute: (interception: SignalReceivedInterception) => void): void;
+}
+/**
+ * The fully-composed activity interceptor produced by
+ * {@link composeActivityInterceptors}. The `execute` hook is always present.
+ * Used internally by the engine to drive activity execution.
+ *
+ * @example
+ * ```ts
+ * import { composeActivityInterceptors, type ComposedActivityInterceptor } from '@lostgradient/weft';
+ * import type { ActivityInterceptor } from '@lostgradient/weft';
+ *
+ * const logger: ActivityInterceptor = {
+ *   async execute(ctx, next) {
+ *     const result = await next(ctx);
+ *     console.log(ctx.activityName, 'done');
+ *     return result;
+ *   },
+ * };
+ *
+ * const composed: ComposedActivityInterceptor = composeActivityInterceptors([logger]);
+ * void composed;
+ * ```
+ */
+export interface ComposedActivityInterceptor {
+    execute(interception: ActivityExecutionInterception, execute: (interception: ActivityExecutionInterception) => Promise<unknown>): Promise<unknown>;
+}

package/dist/core/interceptor/interceptor-interfaces.js

@@ -0,0 +1,9 @@
+export const WORKFLOW_INTERCEPTOR_HOOKS = Object.freeze([
+  "activity",
+  "sleep",
+  "waitForSignal",
+  "workflowStart",
+  "childWorkflow",
+  "query",
+  "signalReceived"
+]);

package/dist/core/interceptor/split.d.ts

@@ -0,0 +1,11 @@
+import type { ActivityInterceptor, Interceptor, WorkflowInterceptor } from './interceptor-interfaces.ts';
+/**
+ * Split a unified interceptor list into the workflow and activity pipelines.
+ *
+ * Interceptors with both workflow-side hooks and `execute` appear in both
+ * arrays. Interceptors without recognized callable hooks are skipped.
+ */
+export declare function splitInterceptors(list: readonly Interceptor[]): {
+    workflow: WorkflowInterceptor[];
+    activity: ActivityInterceptor[];
+};

package/dist/core/interceptor/split.js

@@ -0,0 +1,14 @@
+import { WORKFLOW_INTERCEPTOR_HOOKS } from "./interceptor-interfaces.js";
+export function splitInterceptors(list) {
+  const workflow = [], activity = [];
+  for (const interceptor of list) {
+    if (WORKFLOW_INTERCEPTOR_HOOKS.some((hook) => hasCallableHook(interceptor, hook)))
+      workflow.push(interceptor);
+    if (hasCallableHook(interceptor, "execute"))
+      activity.push(interceptor);
+  }
+  return { workflow, activity };
+}
+function hasCallableHook(interceptor, hook) {
+  return typeof interceptor[hook] === "function";
+}

package/dist/core/interceptor/workflow-composition.d.ts

@@ -0,0 +1,21 @@
+import type { ComposedWorkflowInterceptor, WorkflowInterceptor } from './interceptor-interfaces.ts';
+/**
+ * Compose multiple workflow interceptors into a single interceptor chain.
+ *
+ * @example
+ * ```ts
+ * import { composeWorkflowInterceptors, type WorkflowInterceptor } from '@lostgradient/weft';
+ *
+ * const tracing: WorkflowInterceptor = {
+ *   *activity(ctx, next) {
+ *     console.log('start', ctx.activityName);
+ *     const result = yield* next(ctx);
+ *     console.log('end', ctx.activityName);
+ *     return result;
+ *   },
+ * };
+ * const composed = composeWorkflowInterceptors([tracing]);
+ * void composed;
+ * ```
+ */
+export declare function composeWorkflowInterceptors(interceptors: WorkflowInterceptor[]): ComposedWorkflowInterceptor;

package/dist/core/interceptor/workflow-composition.js

@@ -0,0 +1,116 @@
+function composeActivityHook(interceptors) {
+  return function* composedActivity(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.activity) {
+        const innerNext = chain, bound = interceptor.activity.bind(interceptor);
+        chain = function* (ctx) {
+          return yield* bound(ctx, innerNext);
+        };
+      }
+    }
+    return yield* chain(interception);
+  };
+}
+function composeSleepHook(interceptors) {
+  return function* composedSleep(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.sleep) {
+        const innerNext = chain, bound = interceptor.sleep.bind(interceptor);
+        chain = function* (ctx) {
+          yield* bound(ctx, innerNext);
+        };
+      }
+    }
+    yield* chain(interception);
+  };
+}
+function composeWaitForSignalHook(interceptors) {
+  return function* composedWaitForSignal(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.waitForSignal) {
+        const innerNext = chain, bound = interceptor.waitForSignal.bind(interceptor);
+        chain = function* (ctx) {
+          return yield* bound(ctx, innerNext);
+        };
+      }
+    }
+    return yield* chain(interception);
+  };
+}
+function composeWorkflowStartHook(interceptors) {
+  return function composedWorkflowStart(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.workflowStart) {
+        const innerNext = chain, bound = interceptor.workflowStart.bind(interceptor);
+        chain = (ctx) => {
+          bound(ctx, innerNext);
+        };
+      }
+    }
+    chain(interception);
+  };
+}
+function composeChildWorkflowHook(interceptors) {
+  return async function composedChildWorkflow(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.childWorkflow) {
+        const innerNext = chain, bound = interceptor.childWorkflow.bind(interceptor);
+        chain = (ctx) => {
+          return bound(ctx, innerNext);
+        };
+      }
+    }
+    return chain(interception);
+  };
+}
+function composeQueryHook(interceptors) {
+  return function* composedQuery(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.query) {
+        const innerNext = chain, bound = interceptor.query.bind(interceptor);
+        chain = function* (ctx) {
+          return yield* bound(ctx, innerNext);
+        };
+      }
+    }
+    return yield* chain(interception);
+  };
+}
+function composeSignalReceivedHook(interceptors) {
+  return function composedSignalReceived(interception, execute) {
+    let chain = execute;
+    for (let i = interceptors.length - 1;i >= 0; i--) {
+      const interceptor = interceptors[i];
+      if (interceptor.signalReceived) {
+        const innerNext = chain, bound = interceptor.signalReceived.bind(interceptor);
+        chain = (ctx) => {
+          bound(ctx, innerNext);
+        };
+      }
+    }
+    chain(interception);
+  };
+}
+export function composeWorkflowInterceptors(interceptors) {
+  return {
+    activity: composeActivityHook(interceptors),
+    sleep: composeSleepHook(interceptors),
+    waitForSignal: composeWaitForSignalHook(interceptors),
+    workflowStart: composeWorkflowStartHook(interceptors),
+    childWorkflow: composeChildWorkflowHook(interceptors),
+    query: composeQueryHook(interceptors),
+    signalReceived: composeSignalReceivedHook(interceptors)
+  };
+}

package/dist/core/interceptor.d.ts

@@ -0,0 +1 @@
+export * from './interceptor/index.ts';

package/dist/core/interceptor.js

@@ -0,0 +1 @@
+export * from "./interceptor/index.js";

package/dist/core/json.d.ts

@@ -0,0 +1,56 @@
+/**
+ * JSON primitive values that can safely cross checkpoint, storage, and
+ * tool/effect boundaries.
+ *
+ * @example
+ * ```ts
+ * import type { JSONPrimitive } from '@lostgradient/weft';
+ *
+ * const value: JSONPrimitive = 'ready';
+ * ```
+ */
+export type JSONPrimitive = string | number | boolean | null;
+/**
+ * Recursive JSON-safe value. Used for effect-log outputs, durable operation
+ * payloads, and any data that crosses serialization boundaries inside weft.
+ *
+ * @example
+ * ```ts
+ * import type { JSONValue } from '@lostgradient/weft';
+ *
+ * const value: JSONValue = { count: 1, tags: ['ready'] };
+ * ```
+ */
+export type JSONValue = JSONPrimitive | ReadonlyArray<JSONValue> | {
+    [key: string]: JSONValue;
+};
+/**
+ * Return true when a value is JSON-safe — i.e. composed entirely of strings,
+ * finite numbers, booleans, `null`, arrays of those, and plain objects whose
+ * values are JSON-safe. Detects and rejects cyclic structures.
+ *
+ * @example
+ * ```ts
+ * import { isJSONValue } from '@lostgradient/weft';
+ *
+ * isJSONValue({ count: 1, tags: ['ready'] }); // true
+ * isJSONValue(new Date());                    // false
+ * ```
+ */
+export declare function isJSONValue(value: unknown): value is JSONValue;
+/**
+ * Coerce an unknown value into a JSON-safe value. Already-safe values pass
+ * through unchanged. `undefined`, `bigint`, `symbol`, and `Error` instances
+ * fall back to safe representations; anything else that fails `JSON.stringify`
+ * is replaced with `null`.
+ *
+ * @example
+ * ```ts
+ * import { normalizeJSONValue } from '@lostgradient/weft';
+ *
+ * normalizeJSONValue({ count: 1 });        // { count: 1 }
+ * normalizeJSONValue(new Error('boom'));    // { name: 'Error', message: 'boom' }
+ * normalizeJSONValue(undefined);            // null
+ * ```
+ */
+export declare function normalizeJSONValue(value: unknown): JSONValue;

package/dist/core/json.js

@@ -0,0 +1,77 @@
+export function isJSONValue(value) {
+  const seen = new WeakSet, walk = (current) => {
+    if (isJSONPrimitive(current))
+      return !0;
+    if (isUnsupportedJSONType(current))
+      return !1;
+    if (Array.isArray(current))
+      return isJSONArray(current, seen, walk);
+    if (typeof current === "object")
+      return isJSONObject(current, seen, walk);
+    return !1;
+  };
+  return walk(value);
+}
+export function normalizeJSONValue(value) {
+  if (value === void 0)
+    return null;
+  if (value instanceof Error)
+    return { name: value.name, message: value.message };
+  if (isJSONValue(value))
+    return value;
+  try {
+    const serialized = JSON.stringify(value);
+    if (serialized === void 0)
+      return fallbackJSONValue(value);
+    const parsed = JSON.parse(serialized);
+    return isJSONValue(parsed) ? parsed : fallbackJSONValue(value);
+  } catch {
+    return fallbackJSONValue(value);
+  }
+}
+function isJSONPrimitive(value) {
+  if (value === null)
+    return !0;
+  if (typeof value === "number")
+    return Number.isFinite(value);
+  return typeof value === "string" || typeof value === "boolean";
+}
+function isUnsupportedJSONType(value) {
+  const type = typeof value;
+  return type === "undefined" || type === "bigint" || type === "function" || type === "symbol";
+}
+function isJSONArray(value, seen, walk) {
+  if (seen.has(value))
+    return !1;
+  seen.add(value);
+  for (const item of value)
+    if (!walk(item))
+      return !1;
+  seen.delete(value);
+  return !0;
+}
+function isJSONObject(value, seen, walk) {
+  if (!isPlainObject(value))
+    return !1;
+  if (seen.has(value))
+    return !1;
+  seen.add(value);
+  for (const item of Object.values(value))
+    if (!walk(item))
+      return !1;
+  seen.delete(value);
+  return !0;
+}
+function fallbackJSONValue(value) {
+  if (typeof value === "bigint")
+    return value.toString();
+  if (typeof value === "symbol")
+    return value.description ?? null;
+  return null;
+}
+function isPlainObject(value) {
+  if (!value || typeof value !== "object")
+    return !1;
+  const prototype = Reflect.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}

package/dist/core/list-filter-validation.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Canonical schema and normalizer for {@link ListFilter}. Lives in `core/` so
+ * `engine.list()`, `engine.aggregate()`, and every transport (REST, JSON-RPC
+ * HTTP/WS/stdio) share one validation path.
+ *
+ * `listFilterObjectSchema` is the concrete `z.ZodObject` shape — required
+ * because `aggregate-workflows.ts` composes it with `.omit({ limit, offset })`.
+ *
+ * @module core/list-filter-validation
+ */
+import { z } from 'zod';
+import { isFailureCategory } from './failure-categories.ts';
+import type { FailureCategory, WorkflowStatus } from './types/identity.ts';
+import type { ListFilter } from './types/options.ts';
+import { WeftError } from './weft-error.ts';
+/**
+ * Concrete object schema for {@link ListFilter}. Supports `.omit()` and
+ * `.extend()` for composition (used by the aggregate operation).
+ */
+export declare const listFilterObjectSchema: z.ZodObject<{
+    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>;
+    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>;
+    idPrefix: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    updatedAt: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    executionDeadline: z.ZodOptional<z.ZodObject<{
+        gte: z.ZodOptional<z.ZodNumber>;
+        lte: z.ZodOptional<z.ZodNumber>;
+        gt: z.ZodOptional<z.ZodNumber>;
+        lt: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    failureCategory: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<FailureCategory, unknown, z.core.$ZodTypeInternals<FailureCategory, unknown>>, z.ZodArray<z.ZodType<FailureCategory, unknown, z.core.$ZodTypeInternals<FailureCategory, unknown>>>]>>;
+}, z.core.$strict>;
+/** A flattened Zod issue suitable for cross-transport serialization. */
+export type FilterValidationIssue = {
+    readonly path: ReadonlyArray<string | number>;
+    readonly message: string;
+    readonly code: string;
+};
+/**
+ * Thrown by {@link normalizeListFilter} when the input fails validation.
+ * Carries flattened Zod issues so transport adapters can map directly to the
+ * existing `InvalidParams` fault shape.
+ */
+export declare class ListFilterValidationError extends WeftError<'ListFilterValidationError'> {
+    readonly issues: ReadonlyArray<FilterValidationIssue>;
+    constructor(issues: ReadonlyArray<FilterValidationIssue>);
+}
+/**
+ * Parse and validate a {@link ListFilter}. Returns a typed copy on success;
+ * throws {@link ListFilterValidationError} on failure with structured issues.
+ *
+ * @param input — untrusted filter input (REST query payload, JSON-RPC params,
+ *   or an in-process caller's filter object).
+ */
+export declare function normalizeListFilter(input: unknown): ListFilter;
+export { isFailureCategory };

package/dist/core/list-filter-validation.js

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import { FAILURE_CATEGORIES, isFailureCategory } from "./failure-categories.js";
+import { WeftError } from "./weft-error.js";
+const WORKFLOW_STATUSES = [
+  "pending",
+  "running",
+  "completed",
+  "failed",
+  "cancelled",
+  "timed-out"
+], ID_PREFIX_PATTERN = /^[A-Za-z0-9_-]+$/, workflowStatusSchema = z.enum(WORKFLOW_STATUSES), failureCategorySchema = z.enum(FAILURE_CATEGORIES), timeRangeSchema = z.object({
+  gte: z.number().optional(),
+  lte: z.number().optional(),
+  gt: z.number().optional(),
+  lt: z.number().optional()
+}).strict().refine((range) => range.gte !== void 0 || range.gt !== void 0 || range.lte !== void 0 || range.lt !== void 0, { message: "TimeRange must specify at least one of gte, gt, lte, lt" }).refine((range) => !(range.gte !== void 0 && range.gt !== void 0), {
+  message: "TimeRange may not set both gte and gt"
+}).refine((range) => !(range.lte !== void 0 && range.lt !== void 0), {
+  message: "TimeRange may not set both lte and lt"
+}), searchAttributeValueSchema = z.union([
+  z.string(),
+  z.number(),
+  z.boolean(),
+  z.date(),
+  z.array(z.string())
+]), attributeFilterSchema = z.object({
+  key: z.union([z.string().min(1), z.any()]),
+  value: searchAttributeValueSchema.optional(),
+  gt: searchAttributeValueSchema.optional(),
+  lt: searchAttributeValueSchema.optional(),
+  gte: searchAttributeValueSchema.optional(),
+  lte: searchAttributeValueSchema.optional()
+});
+export const listFilterObjectSchema = z.object({
+  status: z.union([workflowStatusSchema, z.array(workflowStatusSchema)]).optional(),
+  type: 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().min(1).regex(ID_PREFIX_PATTERN, "idPrefix must match [A-Za-z0-9_-]+").optional(),
+  createdAt: timeRangeSchema.optional(),
+  updatedAt: timeRangeSchema.optional(),
+  executionDeadline: timeRangeSchema.optional(),
+  failureCategory: z.union([failureCategorySchema, z.array(failureCategorySchema).min(1)]).optional()
+}).strict();
+function flattenIssue(issue) {
+  const path = [];
+  for (const segment of issue.path)
+    if (typeof segment === "string" || typeof segment === "number")
+      path.push(segment);
+    else
+      path.push(String(segment));
+  return { path, message: issue.message, code: issue.code };
+}
+
+export class ListFilterValidationError extends WeftError {
+  issues;
+  constructor(issues) {
+    const summary = issues.map((issue) => {
+      const path = issue.path.join(".");
+      return path.length > 0 ? `${path}: ${issue.message}` : issue.message;
+    }).join("; ");
+    super("ListFilterValidationError", summary.length > 0 ? summary : "Invalid list filter");
+    this.issues = issues;
+  }
+}
+export function normalizeListFilter(input) {
+  const result = listFilterObjectSchema.safeParse(input ?? {});
+  if (!result.success)
+    throw new ListFilterValidationError(result.error.issues.map(flattenIssue));
+  return result.data;
+}
+
+export { isFailureCategory };