eve 0.50.0 → 0.51.1

package/dist/src/compiled/@workflow/core/serialization/types.d.ts

@@ -147,6 +147,13 @@ export interface SerializableSpecial {
         cause?: unknown;
         context?: RuntimeDecryptionErrorContext;
     };
+    StreamError: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        status?: number;
+        url?: string;
+    };
     Request: {
         method: string;
         url: string;

package/dist/src/compiled/@workflow/core/serialization.d.ts

@@ -1,3 +1,4 @@
+import { createFlushableState } from './flushable-stream.js';
 import { compress, decompress } from './serialization/compression.js';
 import { aesKeyOf, decrypt, deriveRunPayloadKeys, type EncryptionKeyParam, encrypt, isRunPayloadKeys, isSealTarget, type PayloadKey, type RunPayloadKeys, runPayloadKeys, type SealTarget, sealTo } from './serialization/encryption.js';
 import { decodeFormatPrefix, encodeWithFormatPrefix, isEncrypted, peekFormatPrefix } from './serialization/format.js';
@@ -99,7 +100,7 @@ export declare const FRAMED_STREAM_MAX_TOTAL_RECONNECTS = 1000;
  * machinery because we cannot compute an absolute resume position without
  * a tail-index lookup; the returned stream behaves as a single-shot read.
  */
-export declare function createReconnectingFramedStream(runId: string, name: string, startIndex?: number): ReadableStream<Uint8Array>;
+export declare function createReconnectingFramedStream(runId: string, name: string, startIndex?: number, prefetchEncryptionKey?: () => Promise<PayloadKey | undefined>): ReadableStream<Uint8Array>;
 export declare class WorkflowServerWritableStream extends WritableStream<Uint8Array> {
     /**
      * @param runReadyBarrier Turbo mode only: a promise that resolves once the
@@ -220,6 +221,13 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         cause?: unknown;
         context?: import("@workflow/errors").RuntimeDecryptionErrorContext;
     }) => any) | undefined;
+    StreamError?: ((value: {
+        message: string;
+        stack?: string;
+        cause?: unknown;
+        status?: number;
+        url?: string;
+    }) => any) | undefined;
     Request?: ((value: {
         method: string;
         url: string;
@@ -301,6 +309,20 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         reason?: unknown;
     }) => any) | undefined;
 };
+/**
+ * Create a run's object readable without dispatching its stream GET or
+ * encryption-key lookup until the caller reads it. The external reviver starts
+ * its background pipe immediately, so this boundary belongs here—next to the
+ * source/transform assembly—rather than in `Run`.
+ *
+ * @internal
+ */
+export declare function getRunReadableStream<T>(global: Record<string, any>, ops: Promise<void>[], runId: string, name: string, startIndex: number | undefined, cryptoKey: EncryptionKeyParam): ReadableStream<T>;
+/** Options for externally revived object streams. @internal */
+type ExternalReviverOptions = {
+    /** Receives completion state when a wrapper owns the public readable. */
+    onReadableState?: (state: ReturnType<typeof createFlushableState>) => void;
+};
 /**
  * Revivers for deserialization boundary from the client side,
  * receiving the return value from the workflow handler.
@@ -309,7 +331,7 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
  * @param ops
  * @param runId
  */
-export declare function getExternalRevivers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam): Partial<Revivers>;
+export declare function getExternalRevivers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam, options?: ExternalReviverOptions): Partial<Revivers>;
 /**
  * Revivers for deserialization boundary from within the workflow execution
  * environment, receiving arguments from the client side, and return values

package/dist/src/compiled/@workflow/core/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "5.0.0-beta.47";
+export declare const version = "5.0.0-beta.48";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/compiled/@workflow/core/workflow.js

@@ -1 +1 @@
-import{Cr as e,Sr as t,_r as n,nr as r,tr as i,wr as a}from"../../_chunks/workflow/wait-until-BtySPYD0.js";import{i as o,u as s}from"../../_chunks/workflow/dist-DjojkP5e.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-BwAadFfB.js";import{t as m}from"../../_chunks/workflow/sleep-3_A5uOp-.js";import{t as h}from"../../_chunks/workflow/run-DzyAoGh4.js";r(i,h);function g(e){let n=globalThis[t];return n||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),n(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let n=p(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,i=globalThis[a];if(!i)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await i(n,r?{allowReservedAttributes:!0}:{})}function b(t={}){let{namespace:r}=t,i=globalThis[e](r);return Object.create(globalThis.WritableStream.prototype,{[n]:{value:i,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{Cr as e,Sr as t,_r as n,nr as r,tr as i,wr as a}from"../../_chunks/workflow/wait-until-l-cwfJvm.js";import{i as o,u as s}from"../../_chunks/workflow/dist-DMQ3CtWt.js";import{i as c}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-03lzo29R.js";import{t as m}from"../../_chunks/workflow/sleep-Bh3jP9ii.js";import{t as h}from"../../_chunks/workflow/run-BV0S6Zc2.js";r(i,h);function g(e){let n=globalThis[t];return n||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),n(e)}function _(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always generated for you. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let a=g({...r,metadata:i,isWebhook:!0}),{url:o}=l();return a.url=c(o,{type:`webhook`,token:a.token}),a}function v(){function e(t,n){d(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}async function y(e,t={}){let n=p(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,i=globalThis[a];if(!i)throw new o("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await i(n,r?{allowReservedAttributes:!0}:{})}function b(t={}){let{namespace:r}=t,i=globalThis[e](r);return Object.create(globalThis.WritableStream.prototype,{[n]:{value:i,writable:!1}})}function x(){f(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){d(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{o as FatalError,s as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,l as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};

package/dist/src/compiled/@workflow/errors/error-codes.d.ts

@@ -18,6 +18,8 @@ export declare const RUN_ERROR_CODES: {
     readonly MAX_EVENTS_EXCEEDED: "MAX_EVENTS_EXCEEDED";
     /** Workflow replay exceeded the maximum allowed duration */
     readonly REPLAY_TIMEOUT: "REPLAY_TIMEOUT";
+    /** Workflow stream infrastructure failed while reading or writing data */
+    readonly STREAM_ERROR: "STREAM_ERROR";
     /** World response violated the SDK contract and cannot be retried safely */
     readonly WORLD_CONTRACT_ERROR: "WORLD_CONTRACT_ERROR";
     /** Run was delivered to a deployment other than the one it is pinned to */

package/dist/src/compiled/@workflow/errors/index.d.ts

@@ -63,11 +63,18 @@ export declare class WorkflowWorldError extends WorkflowError {
     url?: string;
     /** Retry-After value in seconds, present on 429 and 425 responses */
     retryAfter?: number;
+    /**
+     * The offending argument, present on client-side validation failures
+     * (`code: 'INVALID_ARGUMENT'`). Lets a caller correct the specific
+     * parameter without parsing the message.
+     */
+    field?: string;
     constructor(message: string, options?: {
         status?: number;
         url?: string;
         code?: string;
         retryAfter?: number;
+        field?: string;
         cause?: unknown;
     });
     static is(value: unknown): value is WorkflowWorldError;
@@ -437,6 +444,18 @@ export declare class RunExpiredError extends WorkflowWorldError {
     constructor(message: string);
     static is(value: unknown): value is RunExpiredError;
 }
+/**
+ * Thrown when Workflow's stream infrastructure fails to read or write data.
+ * The failure is attributable to the Workflow service rather than user code.
+ */
+export declare class StreamError extends WorkflowWorldError {
+    constructor(message: string, options?: {
+        cause?: unknown;
+        url?: string;
+        status?: number;
+    });
+    static is(value: unknown): value is StreamError;
+}
 /**
  * Thrown when a stream is no longer readable because its owning run passed its
  * storage-retention boundary. This is terminal: retrying cannot restore data.

package/dist/src/compiled/@workflow/errors/index.js

@@ -1 +1 @@
-import{A as e,C as t,D as n,E as r,O as i,S as a,T as o,_ as s,a as c,b as l,c as u,d,f,g as p,h as m,i as h,k as g,l as _,m as v,n as y,o as b,p as x,r as S,s as C,t as w,u as T,v as E,w as D,x as O,y as k}from"../../_chunks/workflow/dist-DjojkP5e.js";export{w as CorruptedEventLogError,y as ERROR_SLUGS,S as EntityConflictError,h as FatalError,c as HookConflictError,b as HookNotFoundError,C as MaxEventsExceededError,u as PreconditionFailedError,e as RUN_ERROR_CODES,_ as ReplayDivergenceError,T as RetryableError,d as RunExpiredError,f as RunNotSupportedError,x as RuntimeDecryptionError,v as SerializationError,m as StepNotRegisteredError,p as StreamExpiredError,s as ThrottleError,E as TooEarlyError,k as VERCEL_403_ERROR_MESSAGE,l as WorkflowBuildError,O as WorkflowDeploymentMismatchError,a as WorkflowError,t as WorkflowNotRegisteredError,D as WorkflowRunCancelledError,o as WorkflowRunFailedError,r as WorkflowRunNotCompletedError,n as WorkflowRunNotFoundError,i as WorkflowRuntimeError,g as WorkflowWorldError};
+import{A as e,C as t,D as n,E as r,O as i,S as a,T as o,_ as s,a as c,b as l,c as u,d,f,g as p,h as m,i as h,j as g,k as _,l as v,m as y,n as b,o as x,p as S,r as C,s as w,t as T,u as E,v as D,w as O,x as k,y as A}from"../../_chunks/workflow/dist-DMQ3CtWt.js";export{T as CorruptedEventLogError,b as ERROR_SLUGS,C as EntityConflictError,h as FatalError,c as HookConflictError,x as HookNotFoundError,w as MaxEventsExceededError,u as PreconditionFailedError,g as RUN_ERROR_CODES,v as ReplayDivergenceError,E as RetryableError,d as RunExpiredError,f as RunNotSupportedError,S as RuntimeDecryptionError,y as SerializationError,m as StepNotRegisteredError,p as StreamError,s as StreamExpiredError,D as ThrottleError,A as TooEarlyError,l as VERCEL_403_ERROR_MESSAGE,k as WorkflowBuildError,a as WorkflowDeploymentMismatchError,t as WorkflowError,O as WorkflowNotRegisteredError,o as WorkflowRunCancelledError,r as WorkflowRunFailedError,n as WorkflowRunNotCompletedError,i as WorkflowRunNotFoundError,_ as WorkflowRuntimeError,e as WorkflowWorldError};

package/dist/src/compiled/@workflow/world/analytics.d.ts

@@ -121,8 +121,8 @@ export declare const AnalyticsWaitSchema: z.ZodObject<{
 export declare const AnalyticsAttributeKeySchema: z.ZodObject<{
     key: z.ZodString;
     runCount: z.ZodCoercedNumber<unknown>;
-    firstSeenAt: z.ZodCoercedDate<unknown>;
-    lastSeenAt: z.ZodCoercedDate<unknown>;
+    firstSeenAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedDate<unknown>>;
+    lastSeenAt: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodCoercedDate<unknown>>;
 }, z.core.$strip>;
 export type AnalyticsRun = z.infer<typeof AnalyticsRunSchema>;
 export type AnalyticsStep = z.infer<typeof AnalyticsStepSchema>;
@@ -173,6 +173,10 @@ export interface AnalyticsListEventsParams extends AnalyticsListRunScopedParams
     eventType?: AnalyticsEvent['eventType'];
     correlationId?: string;
 }
+/**
+ * @deprecated Parameters of the deprecated `analytics.events.listByCorrelationId`.
+ * Use `AnalyticsListEventsParams` with `list({ runId, correlationId })`.
+ */
 export interface AnalyticsListEventsByCorrelationIdParams {
     correlationId: string;
     /** The run the correlation id belongs to; see `ListEventsByCorrelationIdParams`. */
@@ -181,6 +185,33 @@ export interface AnalyticsListEventsByCorrelationIdParams {
 }
 /** Maximum number of event IDs accepted by one analytics batch lookup. */
 export declare const ANALYTICS_EVENTS_GET_MANY_LIMIT = 100;
+/**
+ * Maximum `pagination.limit` the run-scoped analytics listings accept:
+ * `events.list`, `events.listByCorrelationId`, `steps.list`, `waits.list`.
+ *
+ * Exported so a World implementation can reject an over-large page before a
+ * request goes out. The backend validates the same bound and answers 400, and
+ * a caller that wraps the listing in a `catch` — the common shape, since
+ * analytics is an optional capability — sees only a swallowed failure and an
+ * empty result. Failing in-process with the bound named is diagnosable.
+ */
+export declare const ANALYTICS_RUN_SCOPED_PAGE_LIMIT = 1000;
+/**
+ * Maximum `pagination.limit` the remaining analytics listings accept:
+ * `runs.list`, `attributes.list`, `hooks.list`.
+ *
+ * Deliberately separate from {@link ANALYTICS_RUN_SCOPED_PAGE_LIMIT}: these
+ * listings scan across runs rather than within one, and the backend caps them
+ * an order of magnitude lower. Two names beat one constant that is right for
+ * half its call sites.
+ */
+export declare const ANALYTICS_PAGE_LIMIT = 100;
+/**
+ * Maximum key=value pairs one runs listing may filter by. Each pair adds an
+ * aggregate condition to the backend's attribute prefilter, so the bound is
+ * about query complexity rather than result size.
+ */
+export declare const ANALYTICS_MAX_ATTRIBUTE_FILTERS = 8;
 export interface AnalyticsListHooksParams {
     runId: string;
     pagination?: PaginationOptions;
@@ -215,6 +246,19 @@ export interface Analytics {
          */
         getMany(runId: string, eventIds: readonly string[]): Promise<AnalyticsEvent[]>;
         list(params: AnalyticsListEventsParams): Promise<PaginatedResponse<AnalyticsEvent>>;
+        /**
+         * @deprecated Use `list({ runId, correlationId })`, which issues the same
+         * request and additionally accepts an `eventType` filter.
+         *
+         * This method was the analytics counterpart of the cross-run correlation
+         * lookup, which took the correlation id alone. Requiring a `runId` (a
+         * correlation id is unique per run, not globally) left it a special case
+         * of `list` with no behaviour of its own. Scheduled for removal in the
+         * next major.
+         *
+         * Note this is unrelated to the storage `events.listByCorrelationId`,
+         * which is not deprecated and keeps a distinct endpoint.
+         */
         listByCorrelationId(params: AnalyticsListEventsByCorrelationIdParams): Promise<PaginatedResponse<AnalyticsEvent>>;
     };
     hooks: {

package/dist/src/compiled/@workflow/world/events.d.ts

@@ -680,6 +680,25 @@ export interface CreateEventParams {
      * point there is to keep the first invocation's writes as cheap as
      * possible, and it has no loaded log to extend.
      *
+     * The suspension handler sets it too, on the hook create of a single-hook
+     * suspension. That write is the whole continuation for the hook's own
+     * awaiter — the event it commits is what settles it — so a delta lets the
+     * runtime advance the workflow in the same process instead of enqueueing a
+     * message whose only job is to read back the event it just wrote. It is
+     * asked for on one hook create per suspension because two creates issued
+     * from the same cursor each diff against it, and only one of the returned
+     * deltas can be folded into the log.
+     *
+     * A World that answers it on `hook_created` MUST answer it on the
+     * `hook_conflict` a create whose token is already claimed commits instead.
+     * That event settles the same awaiter — a payload await rejects, a
+     * `hook.getConflict()` resolves with the conflicting run — and the runtime
+     * continues over it in-process just the same, so withholding the delta
+     * there would silently cost a delivery on exactly the path the caller
+     * asked to avoid one on. The delta is keyed on the requested event type,
+     * not the committed one; there is nothing extra to compute, since it is the
+     * same slice of the log either way.
+     *
      * The cursor MUST share `events.list` semantics: the returned `events`
      * are everything sorted strictly after `sinceCursor`, `cursor` is the
      * position past the last returned event, and `hasMore` indicates a
@@ -787,7 +806,7 @@ export type EventResult<T extends EventType = EventType> = {
     maxEvents?: number;
 } & ({
     /**
-     * Events with data resolved. Four producers populate this:
+     * Events with data resolved. Five producers populate this:
      *
      * - On a `run_started` response: all events up to this point, so the
      *   runtime can skip the initial `events.list` call and reduce TTFB.
@@ -795,6 +814,12 @@ export type EventResult<T extends EventType = EventType> = {
      *   the caller passed {@link CreateEventParams.sinceCursor}: the delta
      *   of events written strictly after that cursor, so the inline loop
      *   can skip the per-step incremental `events.list` round-trip.
+     * - On a hook-create write when the caller passed
+     *   {@link CreateEventParams.sinceCursor}: the same delta, which
+     *   includes the event the create committed — the `hook_created`, or
+     *   the `hook_conflict` of an already-claimed token — so the hook's
+     *   awaiter can be settled in the writing process rather than by a
+     *   re-invocation that reads the event back.
      * - On a `hook_received` response when the caller passed
      *   {@link CreateEventParams.preloadEvents}: the run's current replay
      *   log through the canonical `hook_received`, so the lazy hook queue

package/dist/src/compiled/@workflow/world/index.d.ts

@@ -1,5 +1,5 @@
 export type * from './analytics.js';
-export { ANALYTICS_EVENTS_GET_MANY_LIMIT, AnalyticsAttributeKeySchema, AnalyticsEventSchema, AnalyticsHookSchema, AnalyticsRunSchema, AnalyticsStepSchema, AnalyticsWaitSchema, } from './analytics.js';
+export { ANALYTICS_EVENTS_GET_MANY_LIMIT, ANALYTICS_MAX_ATTRIBUTE_FILTERS, ANALYTICS_PAGE_LIMIT, ANALYTICS_RUN_SCOPED_PAGE_LIMIT, AnalyticsAttributeKeySchema, AnalyticsEventSchema, AnalyticsHookSchema, AnalyticsRunSchema, AnalyticsStepSchema, AnalyticsWaitSchema, } from './analytics.js';
 export type * from './attributes.js';
 export { ATTRIBUTE_KEY_MAX_LENGTH, ATTRIBUTE_MAX_PER_RUN, ATTRIBUTE_VALUE_MAX_BYTES, AttributeChangeSchema, AttributeChangesSchema, AttributeKeySchema, AttributeValidationError, AttributeValueSchema, applyAttributeChanges, PARENT_RUN_ID_ATTRIBUTE, RESERVED_ATTRIBUTE_KEY_PREFIX, ROOT_RUN_ID_ATTRIBUTE, validateAttributeChanges, } from './attributes.js';
 export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envFlag, envNumber, getMaxEventsPerRun, } from './env-config.js';

package/dist/src/compiled/@workflow/world/runs.d.ts

@@ -104,7 +104,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     createdAt: z.ZodCoercedDate<unknown>;
     updatedAt: z.ZodCoercedDate<unknown>;
     status: z.ZodLiteral<"completed">;
-    output: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
+    output: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     error: z.ZodOptional<z.ZodUndefined>;
     completedAt: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>, z.ZodObject<{
@@ -123,7 +123,7 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     updatedAt: z.ZodCoercedDate<unknown>;
     status: z.ZodLiteral<"failed">;
     output: z.ZodOptional<z.ZodUndefined>;
-    error: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
+    error: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
     completedAt: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>], "status">;
 export type WorkflowRun = z.infer<typeof WorkflowRunSchema>;