eve 0.52.4 → 0.53.0

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

@@ -309,6 +309,28 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         reason?: unknown;
     }) => any) | undefined;
 };
+/**
+ * Resolves the owner's encryption key, preferring its public key, then its
+ * deployment, and finally its run record.
+ * @internal
+ */
+export declare function getForwardedWritableEncryptionKey(runId: string, deploymentId: string | undefined, encryptionPublicKey: string | undefined): Promise<PayloadKey | undefined>;
+/** Tags a forwarded writable with its owner's metadata. @internal */
+export declare function tagForwardedWritableTarget(writable: WritableStream, { deploymentId, encryptionPublicKey, }: {
+    deploymentId?: string;
+    encryptionPublicKey?: string;
+}): void;
+/** Creates and tags a forwarded writable targeting the owner run. @internal */
+export declare function createForwardedWritable<W = any>({ global, ops, runId, name, key, deploymentId, encryptionPublicKey, runReadyBarrier, }: {
+    global: Record<string, any>;
+    ops: Promise<any>[];
+    runId: string;
+    name: string;
+    key: EncryptionKeyParam;
+    deploymentId?: string;
+    encryptionPublicKey?: string;
+    runReadyBarrier?: Promise<unknown>;
+}): WritableStream<W>;
 /**
  * Create a run's object readable without dispatching its stream GET or
  * encryption-key lookup until the caller reads it. The external reviver starts

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

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

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

@@ -1 +1 @@
-import{Ar as e,Cr as t,Fr as n,Nr as r,Tr as i,jr as a,nr as o,rr as s,t as c,vr as l,wr as u}from"../../_chunks/workflow/attribute-changes-DpruylJZ.js";import{i as d,u as f}from"../../_chunks/workflow/dist-BIO9Inoc.js";import{i as p}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{t as m}from"../../_chunks/workflow/sleep-BKxoNDRv.js";import{t as h}from"../../_chunks/workflow/run-vsAdI41O.js";s(o,h);function g(e){let n=globalThis[t];return n||a(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),n(e)}function _(e){let{respondWith:t,token:r,...i}=e??{};if(r!==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 a;t!==void 0&&(a={respondWith:t});let o=g({...i,metadata:a,isWebhook:!0}),{url:s}=n();return o.url=p(s,{type:`webhook`,token:o.token}),o}function v(){function e(t,n){r(`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=c(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,a=globalThis[i];if(!a)throw new d("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(n,r?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[u](t);return Object.create(globalThis.WritableStream.prototype,{[l]:{value:n,writable:!1}})}function x(){e(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){r(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{d as FatalError,f as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,n as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};
+import{Dr as e,Er as t,Ir as n,Nr as r,Or as i,Pr as a,Rr as o,ar as s,or as c,t as l,xr as u}from"../../_chunks/workflow/attribute-changes-C6H-fRVP.js";import{i as d,u as f}from"../../_chunks/workflow/dist-xTushGCp.js";import{i as p}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{t as m}from"../../_chunks/workflow/sleep-6cG0F99-.js";import{t as h}from"../../_chunks/workflow/run-BM2OFphk.js";c(s,h);function g(e){let n=globalThis[t];return n||a(`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:s}=o();return a.url=p(s,{type:`webhook`,token:a.token}),a}function v(){function e(t,r){n(`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=l(e,t);if(n.length===0)return;let r=t.allowReservedAttributes===!0,a=globalThis[i];if(!a)throw new d("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(n,r?{allowReservedAttributes:!0}:{})}function b(t={}){let{namespace:n}=t,r=globalThis[e](n);return Object.create(globalThis.WritableStream.prototype,{[u]:{value:r,writable:!1}})}function x(){r(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){n(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{d as FatalError,f as RetryableError,g as createHook,_ as createWebhook,v as defineHook,x as getStepMetadata,o as getWorkflowMetadata,b as getWritable,S as resumeHook,y as setAttributes,m as sleep};

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

@@ -437,11 +437,45 @@ export declare class EntityConflictError extends WorkflowWorldError {
  * Thrown when a run is no longer available, either because it has been
  * cleaned up, expired, or already reached a terminal state (completed/failed).
  *
- * The workflow runtime handles this error automatically. Users interacting
- * with world storage backends directly may encounter it.
+ * Also thrown by `await run.returnValue` when the run's data passed its
+ * retention boundary — because it was started with
+ * `experimental_retention: 0`, or simply because it aged out of the World's
+ * default window. The run's metadata usually outlives its payloads, so
+ * `runStatus` and `expiredAt` are populated when the World still has them: the
+ * caller can tell "it succeeded, but the result is gone" from "it failed".
+ * When even the metadata is gone the World reports the run as missing and you
+ * get {@link WorkflowRunNotFoundError} instead.
+ *
+ * This is terminal. Retrying cannot bring the data back.
  */
 export declare class RunExpiredError extends WorkflowWorldError {
-    constructor(message: string);
+    /** The run whose data expired, when the caller knew it. */
+    readonly runId?: string | undefined;
+    /**
+     * The run's terminal status, when its metadata outlived its payloads.
+     * Lets a caller distinguish a successful run whose result is gone from a
+     * failed one whose error is gone.
+     *
+     * Named `runStatus` rather than `status` because the base
+     * {@link WorkflowWorldError} already carries the HTTP `status`.
+     */
+    readonly runStatus?: string | undefined;
+    /** When the data passed its retention boundary, if the World reports it. */
+    readonly expiredAt?: Date | undefined;
+    constructor(message: string, 
+    /** The run whose data expired, when the caller knew it. */
+    runId?: string | undefined, 
+    /**
+     * The run's terminal status, when its metadata outlived its payloads.
+     * Lets a caller distinguish a successful run whose result is gone from a
+     * failed one whose error is gone.
+     *
+     * Named `runStatus` rather than `status` because the base
+     * {@link WorkflowWorldError} already carries the HTTP `status`.
+     */
+    runStatus?: string | undefined, 
+    /** When the data passed its retention boundary, if the World reports it. */
+    expiredAt?: Date | undefined);
     static is(value: unknown): value is RunExpiredError;
 }
 /**

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,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-BIO9Inoc.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};
+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-xTushGCp.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/attributes-validation.d.ts

@@ -6,6 +6,74 @@ export interface AttributeChange {
 export declare const RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
 export declare const ROOT_RUN_ID_ATTRIBUTE = "$rootRunId";
 export declare const PARENT_RUN_ID_ATTRIBUTE = "$parentRunId";
+/**
+ * Reserved attribute carrying the caller's data-retention preference, seeded
+ * by `start({ retention })`. Worlds read it when a run reaches a terminal
+ * state to decide how long user data is kept. Absent means "the World
+ * decides", which is also what `'default'` requests.
+ *
+ * The value is a duration written as a decimal integer, and **its unit is
+ * deliberately not decided yet**. `'0'` is the only duration implemented,
+ * and zero is the one value that means the same thing in every unit, so it
+ * can ship ahead of that decision: it commits to a shape without committing
+ * to a scale. A World that reads a non-zero value must treat it as
+ * unsupported and fall back to its own default — that is the safe direction,
+ * because it keeps data that was asked to be kept rather than deleting data
+ * on the strength of a number it cannot scale.
+ */
+export declare const RETENTION_ATTRIBUTE = "$retention";
+/**
+ * Value accepted by `start({ retention })`, before it is encoded into
+ * {@link RETENTION_ATTRIBUTE}.
+ *
+ * - `0` — delete user data as soon as the run reaches a terminal state.
+ * - `'default'` — let the World decide; the same as omitting the option.
+ *
+ * A number rather than a string because the value is a duration and this
+ * namespace is meant to grow. It is the literal `0` rather than `number`
+ * because zero is the only duration that can be honored while the unit is
+ * undecided: the narrow type is what stops a caller writing some other
+ * duration and silently getting the World's default instead.
+ */
+export type RunRetention = 0 | 'default';
+/** Wire value of {@link RETENTION_ATTRIBUTE} meaning "delete on finish". */
+export declare const RETENTION_ZERO = "0";
+/** Wire value meaning "use the World's default". Equivalent to absence. */
+export declare const RETENTION_DEFAULT = "default";
+/** How a World should treat a run's {@link RETENTION_ATTRIBUTE}. */
+export interface ResolvedRunRetention {
+    /** `'none'` deletes user data at terminal; `'default'` keeps it. */
+    mode: 'none' | 'default';
+    /** The raw attribute value, when the run carried one. */
+    raw?: string;
+    /**
+     * True when the value parsed as a non-negative integer — which for every
+     * value except `0` still means unsupported. Deliberately not the parsed
+     * number: there is no unit to interpret it in yet (see
+     * {@link RETENTION_ATTRIBUTE}), and exposing one invites a caller to guess.
+     */
+    wellFormed: boolean;
+    /** True when this is a value no World implements today. */
+    unsupported: boolean;
+}
+/**
+ * Resolve a run's retention preference from its attributes.
+ *
+ * Shared by every World that implements retention, and that sharing is the
+ * point: two Worlds with independently written parsers can drift, and drift
+ * here means one World deleting a run another keeps. The safe direction is
+ * fixed — anything but `'0'` resolves to `'default'`, so a value this version
+ * does not understand keeps the data rather than destroying it.
+ */
+export declare function readRunRetention(attributes: Record<string, string> | undefined): ResolvedRunRetention;
+/**
+ * Whether a finished run asked for its user data to be deleted now.
+ *
+ * The predicate most World call sites want. `readRunRetention` is there when
+ * a caller also needs to report *why* it declined — an unsupported value is a
+ * rollout signal worth surfacing, not just a no-op.
+ */
+export declare function purgesUserDataOnFinish(attributes: Record<string, string> | undefined): boolean;
 export declare const ATTRIBUTE_KEY_MAX_LENGTH = 256;
 export declare const ATTRIBUTE_VALUE_MAX_BYTES = 256;
 export declare const ATTRIBUTE_MAX_PER_RUN = 64;

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

@@ -1,7 +1,7 @@
 export type * 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 { ATTRIBUTE_KEY_MAX_LENGTH, ATTRIBUTE_MAX_PER_RUN, ATTRIBUTE_VALUE_MAX_BYTES, AttributeChangeSchema, AttributeChangesSchema, AttributeKeySchema, AttributeValidationError, AttributeValueSchema, applyAttributeChanges, PARENT_RUN_ID_ATTRIBUTE, purgesUserDataOnFinish, RESERVED_ATTRIBUTE_KEY_PREFIX, RETENTION_ATTRIBUTE, RETENTION_DEFAULT, RETENTION_ZERO, type ResolvedRunRetention, ROOT_RUN_ID_ATTRIBUTE, type RunRetention, readRunRetention, validateAttributeChanges, } from './attributes.js';
 export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envFlag, envNumber, getMaxEventsPerRun, } from './env-config.js';
 export type * from './events.js';
 export { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, classifyEntityEvent, EventSchema, EventTypeSchema, entityEventClass, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isSealedNoopEvent, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_ENTITY_KEY, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_EVENT_CLASSES, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';

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

@@ -6,6 +6,21 @@ import type { Queue } from './queue.js';
 import type { BulkCancelWorkflowRunsRequest, BulkCancelWorkflowRunsResult, GetWorkflowRunParams, ListWorkflowRunsParams, WaitForTerminalRunStatusParams, WorkflowRun, WorkflowRunWithoutData } from './runs.js';
 import type { GetChunksOptions, PaginatedResponse, StreamChunksResponse, StreamInfoResponse } from './shared.js';
 import type { GetStepParams, ListWorkflowRunStepsParams, Step, StepWithoutData } from './steps.js';
+export interface StreamWriteSession {
+    /**
+     * Write one ordered group from this in-memory writer lifetime.
+     * `chunkSeq` is writer-local and identifies the first chunk in `chunks`.
+     */
+    write(chunkSeq: number, chunks: (string | Uint8Array)[]): Promise<void>;
+    /** Close this writer lifetime after all prior writes are durable. */
+    close(): Promise<void>;
+    /** Release transport resources without semantically closing the stream. */
+    dispose?(): Promise<void> | void;
+}
+export interface CreateStreamWriteSessionOptions {
+    /** Stable observational id for this in-memory writer lifetime. */
+    writerId: `wrtr_${string}`;
+}
 export interface Streamer {
     /**
      * Number of milliseconds a stream waits for additional chunks to arrive
@@ -22,6 +37,12 @@ export interface Streamer {
      */
     streamFlushIntervalMs?: number;
     streams: {
+        /**
+         * Optionally create a stateful writer session. Core creates at most one
+         * session per in-memory WritableStream and otherwise uses the stateless
+         * write/writeMulti/close methods below unchanged.
+         */
+        createWriteSession?(runId: string, name: string, options: CreateStreamWriteSessionOptions): StreamWriteSession;
         write(runId: string, name: string, chunk: string | Uint8Array): Promise<void>;
         /**
          * Write multiple chunks to a stream in a single operation.