eve 0.6.0-beta.9 → 0.7.2

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

@@ -1,3 +1,4 @@
+import type { AttributeChange } from '#compiled/@workflow/world/index.js';
 import type { Serializable } from './schemas.js';
 export interface StepInvocationQueueItem {
     type: 'step';
@@ -14,6 +15,8 @@ export interface HookInvocationQueueItem {
     token: string;
     metadata?: Serializable;
     hasCreatedEvent?: boolean;
+    /** Whether the workflow is awaiting `hook.getConflict()` for this hook */
+    hasConflictAwaiter?: boolean;
     disposed?: boolean;
     isWebhook?: boolean;
     isSystem?: boolean;
@@ -26,7 +29,13 @@ export interface WaitInvocationQueueItem {
     resumeAt: Date;
     hasCreatedEvent?: boolean;
 }
-export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | WaitInvocationQueueItem;
+export interface AttributeInvocationQueueItem {
+    type: 'attribute';
+    correlationId: string;
+    changes: AttributeChange[];
+    allowReservedAttributes?: true;
+}
+export type QueueItem = StepInvocationQueueItem | HookInvocationQueueItem | WaitInvocationQueueItem | AttributeInvocationQueueItem;
 /**
  * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do
  * not yet have corresponding entries in the event log. The workflow
@@ -39,6 +48,7 @@ export declare class WorkflowSuspension extends Error {
     stepCount: number;
     hookCount: number;
     waitCount: number;
+    attributeCount: number;
     hookDisposedCount: number;
     abortCount: number;
     constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis);

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

@@ -1,2 +1,2 @@
-import{c as e,i as t}from"../../_chunks/workflow/dist-6a3viBXZ.js";import{c as n,l as r,nt as i,rt as a,s as o,tt as s}from"../../_chunks/workflow/symbols-BWCAoPHE.js";import{Bt as c,C as l,I as u,R as d,Rt as f,Vt as p,m,n as h,x as g,zt as _}from"../../_chunks/workflow/resume-hook-0Zk0zSvq.js";import{n as v,t as y}from"../../_chunks/workflow/sleep-DXZr2BgM.js";function b(e){i(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,b)}function x(e){i(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,x)}function S({schema:e}={}){function t(e){i(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await h(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
-`)}`)}return await h(t,r.value)}}}const C=Symbol.for(`@workflow/setAttributes//unsupportedWorldWarned`);async function w(e,n={}){let r=d.getStore()?.workflowMetadata?.workflowRunId;if(!r)throw new t(`experimental_setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let i=v(e,n);if(i.length===0)return;let a=await f();if(typeof a.runs.experimentalSetAttributes!=`function`){let e=globalThis;if(!e[C]){e[C]=!0;let t=`name`in a&&typeof a.name==`string`?a.name:``,n=t?` (${t})`:``;console.warn(`[workflow] setAttributes: the current world implementation${n} does not implement experimentalSetAttributes; this call (and any subsequent setAttributes calls in this process) is a no-op. Attributes will become available once the world adapter adds support.`)}return}await a.runs.experimentalSetAttributes(r,i,n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{})}function T(){let e=d.getStore();return e||s(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,T),e.stepMetadata}function E(){let e=d.getStore();return e||a(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,E),e.workflowMetadata}function D(e={}){let t=d.getStore();t||a(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,D);let{namespace:i}=e,s=t.workflowMetadata.workflowRunId,f=u(s,i),h=t.writables??=new Map,v=h.get(f);if(v)return v.writable;let y=l(g(globalThis,t.ops,s,t.encryptionKey),t.encryptionKey),b=new m(s,f),x=_();return t.ops.push(x.promise),c(y.readable,b,x).catch(()=>{}),p(y.writable,x),Object.defineProperty(y.writable,o,{value:f,writable:!1}),Object.defineProperty(y.writable,r,{value:s,writable:!1}),t.workflowDeploymentId&&Object.defineProperty(y.writable,n,{value:t.workflowDeploymentId,writable:!1}),h.set(f,{writable:y.writable,state:x}),y.writable}export{t as FatalError,e as RetryableError,b as createHook,x as createWebhook,S as defineHook,w as experimental_setAttributes,T as getStepMetadata,E as getWorkflowMetadata,D as getWritable,y as sleep};
+import{c as e,i as t}from"../../_chunks/workflow/dist-6a3viBXZ.js";import{Jn as n,Jt as r,Kt as i,L as a,R as o,S as s,Xn as c,Yn as l,an as u,h as d,in as f,on as p,qt as m,rn as h,t as g,w as _}from"../../_chunks/workflow/attribute-changes-DGVGRGfw.js";import{n as v}from"../../_chunks/workflow/resume-hook-DMSadN9o.js";import{t as y}from"../../_chunks/workflow/sleep-CpXfoXLF.js";function b(e){l(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,b)}function x(e){l(`createWebhook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-webhook`,x)}function S({schema:e}={}){function t(e){l(`defineHook().create()`,`https://workflow-sdk.dev/docs/api-reference/workflow/define-hook`,t)}return{create:t,async resume(t,n){if(!e?.[`~standard`])return await v(t,n);let r=e[`~standard`].validate(n);if(r instanceof Promise&&(r=await r),r.issues){let e=r.issues.map(e=>{let t=e.path?.map(e=>String(typeof e==`object`&&e?e.key:e)).join(`.`);return t?`  at "${t}": ${e.message}`:`  ${e.message}`});throw Error(`Hook payload did not match the defined schema:\n${e.join(`
+`)}`)}return await v(t,r.value)}}}async function C(e,n={}){let r=o.getStore(),i=r?.workflowMetadata?.workflowRunId;if(!i)throw new t(`experimental_setAttributes() must be called from a 'use workflow' or 'use step' function. Calling it from plain host code is not supported.`);let a=g(e,n);a.length!==0&&await(await h()).events.create(i,{eventType:`attr_set`,specVersion:4,eventData:{changes:a,writer:{type:`step`,stepId:r.stepMetadata.stepId,attempt:r.stepMetadata.attempt},...n.allowReservedAttributes===!0?{allowReservedAttributes:!0}:{}}})}function w(){let e=o.getStore();return e||n(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,w),e.stepMetadata}function T(){let e=o.getStore();return e||c(`getWorkflowMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-workflow-metadata`,T),e.workflowMetadata}function E(e={}){let t=o.getStore();t||c(`getWritable()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-writable`,E);let{namespace:n}=e,l=t.workflowMetadata.workflowRunId,h=a(l,n),g=t.writables??=new Map,v=g.get(h);if(v)return v.writable;let y=_(s(globalThis,t.ops,l,t.encryptionKey,!0),t.encryptionKey),b=new d(l,h),x=f();return t.ops.push(x.promise),u(y.readable,b,x).catch(()=>{}),p(y.writable,x),Object.defineProperty(y.writable,i,{value:h,writable:!1}),Object.defineProperty(y.writable,r,{value:l,writable:!1}),t.workflowDeploymentId&&Object.defineProperty(y.writable,m,{value:t.workflowDeploymentId,writable:!1}),g.set(h,{writable:y.writable,state:x}),y.writable}export{t as FatalError,e as RetryableError,b as createHook,x as createWebhook,S as defineHook,C as experimental_setAttributes,w as getStepMetadata,T as getWorkflowMetadata,E as getWritable,y as sleep};

package/dist/src/compiled/@workflow/core/runtime/helpers.d.ts

@@ -5,7 +5,7 @@ import { type CryptoKey } from '../encryption.js';
  * Ensures the workflow name only contains safe characters before
  * interpolating it into the queue name string.
  */
-export declare function getWorkflowQueueName(workflowName: string): ValidQueueName;
+export declare function getWorkflowQueueName(workflowName: string, namespace?: string): ValidQueueName;
 /**
  * Result of a health check operation.
  */
@@ -46,7 +46,9 @@ export interface HealthCheckOptions {
     /** Deployment ID to send the health check to. Falls back to process.env.VERCEL_DEPLOYMENT_ID. */
     deploymentId?: string;
 }
-export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions): Promise<HealthCheckResult>;
+export declare function healthCheck(world: World, endpoint: HealthCheckEndpoint, options?: HealthCheckOptions & {
+    namespace?: string;
+}): Promise<HealthCheckResult>;
 /**
  * Loads workflow run events by iterating through all pages of paginated
  * results. Events are returned in chronological (ascending) order for

package/dist/src/compiled/@workflow/core/runtime/start.d.ts

@@ -10,6 +10,12 @@ export interface StartOptionsBase {
      * The spec version to use for the workflow run. Defaults to the latest version.
      */
     specVersion?: number;
+    /**
+     * Plaintext attributes to seed on the run as it is created.
+     *
+     * Available for native-attributes runs (spec version 4 and later).
+     */
+    attributes?: Record<string, string>;
 }
 export interface StartOptionsWithDeploymentId extends StartOptionsBase {
     /**

package/dist/src/compiled/@workflow/core/runtime/suspension-handler.d.ts

@@ -24,10 +24,23 @@ export interface SuspensionHandlerResult {
      * into the same batch boundary.
      */
     createdStepCorrelationIds: Set<string>;
-    /** Timeout from waits, if any */
-    timeoutSeconds?: number;
+    /**
+     * The soonest pending wait, if any: seconds until it elapses and the
+     * correlationId of the wait that produced that timeout. The
+     * correlationId seeds the idempotency key for the wait-continuation
+     * queue message so that repeated suspension passes over the same
+     * pending wait collapse into a single delayed continuation.
+     */
+    waitTimeout?: {
+        seconds: number;
+        correlationId: string;
+    };
     /** Whether a hook conflict was detected (should re-invoke immediately) */
     hasHookConflict: boolean;
+    /** Whether a `hook.getConflict()` awaiter needs the workflow to continue immediately */
+    hasAwaitedHookCreation: boolean;
+    /** Whether native workflow attribute events were written for replay. */
+    hasAttributeEvents: boolean;
 }
 /**
  * Handles a workflow suspension by processing all pending operations (hooks, steps, waits).

package/dist/src/compiled/@workflow/core/runtime/wait-continuation.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Wait-continuation dispatch: delay + idempotency-key selection.
+ *
+ * When V2 suspension processing observes a pending wait, it enqueues a
+ * delayed "continuation" message that fires once the wait elapses and
+ * drives the next replay (which completes the wait via the "complete
+ * elapsed waits" pass). This module decides the message's `delaySeconds`
+ * and `idempotencyKey`.
+ *
+ * The continuation is keyed on the wait's correlationId: while a wait is
+ * pending, every replay pass over the run re-observes it (e.g., once per
+ * step completion in `Promise.all([steps..., sleep()])`), and without
+ * dedupe each pass would enqueue another delayed continuation — each one
+ * a spurious full replay when the wait elapses, and each a fresh message
+ * that resets the delivery-attempt runaway guard. A key is attached in
+ * all cases: some worlds (e.g. world-postgres) serialize key-less
+ * workflow messages per run, which would park the continuation behind
+ * the handler's own inline step execution and defeat the race semantics
+ * the continuation exists to provide.
+ *
+ * The bare correlationId cannot be the key in every case, though: world
+ * dedupe windows outlive the first delivery (VQS keeps idempotency
+ * records until message-retention TTL; world-postgres keeps a
+ * completed-keys cache), so once a key has been used, a later enqueue
+ * under the same key is silently dropped. Any situation where a
+ * continuation is delivered while its wait is still pending therefore
+ * needs a fresh key for the re-enqueue, or the wait's timer is lost and
+ * the run stalls until unrelated traffic happens to wake it. Two such
+ * situations exist, each with its own key variation:
+ *
+ * - Waits longer than the maximum queue delay are chained: the delay is
+ *   clamped to `WAIT_CONTINUATION_MAX_DELAY_SECONDS` (23h — VQS messages
+ *   have a 24h retention limit, and one hour of buffer matches
+ *   world-vercel's own clamp for delayed re-enqueues), so the
+ *   continuation intentionally fires early, re-observes the wait, and
+ *   must enqueue the next hop. The key is suffixed with the hop index
+ *   (`ceil(timeoutSeconds / maxDelay)`): stable for every re-observation
+ *   within the same hop window (so passes dedupe), decremented at each
+ *   hop delivery (so the chain always advances). Worlds without a delay
+ *   limit (world-postgres, world-local) simply take the same ≤23h hops.
+ *
+ * - Near-elapsed waits (≤2s remaining) get a second-bucketed suffix. A
+ *   continuation delivered marginally early (clock skew between the
+ *   enqueuing and handling hosts; the ceil() on the delay can leave a ~0
+ *   margin) re-observes the wait as pending with ~1s remaining and must
+ *   be able to enqueue a fresh short-delay retry. The bucket suffix
+ *   keeps that retry enqueueable (its ≥1s delay guarantees a later
+ *   bucket) while still collapsing same-instant duplicates.
+ *
+ * Mid-range waits (more than the near-elapsed threshold, at most one
+ * hop) use the bare correlationId: every re-observation targets the same
+ * deadline, so deduping to the first message is semantically lossless.
+ * Host clock skew beyond the near-elapsed threshold could in principle
+ * deliver such a continuation early enough to re-observe its wait and
+ * lose the re-enqueue to the burnt key; the threshold is the skew
+ * tolerance we accept for the benefit of exactly-one continuation per
+ * wait.
+ */
+/**
+ * Maximum `delaySeconds` for a single wait-continuation message. Waits
+ * longer than this are chained across multiple hops. 23 hours: VQS
+ * messages have a 24h retention limit; the 1h buffer mirrors
+ * world-vercel's `MAX_DELAY_SECONDS`.
+ */
+export declare const WAIT_CONTINUATION_MAX_DELAY_SECONDS = 82800;
+/**
+ * Waits with at most this many seconds remaining use a second-bucketed
+ * idempotency key so an early-delivered continuation can re-enqueue its
+ * short-delay retry. This is also the host clock-skew tolerance for
+ * mid-range waits keyed on the bare correlationId.
+ */
+export declare const NEAR_ELAPSED_WAIT_THRESHOLD_SECONDS = 2;
+export interface WaitContinuationDispatch {
+    delaySeconds: number;
+    idempotencyKey: string;
+}
+/**
+ * Computes the queue delay and idempotency key for a wait-continuation
+ * message. `timeoutSeconds` is the time until the wait's `resumeAt`
+ * (floored at 1s by the suspension handler); `waitCorrelationId`
+ * identifies the wait so repeated suspension passes dedupe.
+ */
+export declare function getWaitContinuationDispatch(timeoutSeconds: number, waitCorrelationId: string, now?: number): WaitContinuationDispatch;
+//# sourceMappingURL=wait-continuation.d.ts.map

package/dist/src/compiled/@workflow/core/runtime/wait-until.d.ts

@@ -0,0 +1,18 @@
+export declare function waitUntil(promise: Promise<unknown>): void;
+/**
+ * Schedule a background promise via `waitUntil`, guaranteeing that the
+ * promise handed to `waitUntil` can never reject. Nothing consumes a
+ * `waitUntil` promise, so a rejection surfaces as an `unhandledRejection`
+ * and can crash the process — even when the same underlying error is
+ * correctly handled by an awaited copy elsewhere.
+ *
+ * Expected client-disconnect errors (`AbortError` / `ResponseAborted`)
+ * are ignored. Any other error is passed to `onError` and swallowed.
+ */
+export declare function safeWaitUntil(promise: Promise<unknown>, onError: (err: unknown) => void): void;
+/**
+ * A small wrapper around `waitUntil` that also returns
+ * the result of the awaited promise.
+ */
+export declare function waitedUntil<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=wait-until.d.ts.map

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

@@ -18,5 +18,7 @@ export { createWorld, getWorld, getWorldHandlers, setWorld, } from './runtime/wo
  * @param workflowCode - The workflow bundle code containing all workflow functions
  * @returns A function that can be used as a Vercel API route
  */
-export declare function workflowEntrypoint(workflowCode: string): (req: Request) => Promise<Response>;
+export declare function workflowEntrypoint(workflowCode: string, options?: {
+    namespace?: string;
+}): (req: Request) => Promise<Response>;
 //# sourceMappingURL=runtime.d.ts.map