eve 0.22.4 → 0.22.6

package/dist/src/compiled/@workflow/core/workflow/set-attributes.d.ts

@@ -1,7 +1,7 @@
 /**
- * Options accepted by `experimental_setAttributes`.
+ * Options accepted by `setAttributes`.
  */
-export interface ExperimentalSetAttributesOptions {
+export interface SetAttributesOptions {
     /**
      * Permit attribute keys that start with the reserved `$` prefix.
      * **Default: `false`.**
@@ -20,14 +20,13 @@ export interface ExperimentalSetAttributesOptions {
      */
     allowReservedAttributes?: boolean;
 }
+/**
+ * @deprecated Use {@link SetAttributesOptions} instead.
+ */
+export type ExperimentalSetAttributesOptions = SetAttributesOptions;
 /**
  * Attach plaintext string key/value metadata to the current workflow run.
  *
- * **EXPERIMENTAL.** The `experimental_` prefix is deliberate — the
- * shape, semantics, and dispatch path are likely to change before this
- * is renamed to a stable export. Use only when you can absorb a
- * breaking rename later.
- *
  * Callable only from a workflow body (`'use workflow'`). The call is
  * dispatched as a native `attr_set` event and materialized on the run.
  *
@@ -41,33 +40,38 @@ export interface ExperimentalSetAttributesOptions {
  * trying to write a `$`-prefixed key throws `FatalError`. If you are a
  * framework author and need to set a reserved key, pass
  * `{ allowReservedAttributes: true }` as the second argument — see
- * `ExperimentalSetAttributesOptions` for the trade-offs.
+ * `SetAttributesOptions` for the trade-offs.
  *
- * **WARNING**: While this feature is experimental, calling e.g.
- * `Promise.all([experimental_setAttributes({ a: '1' }), experimental_setAttributes({ a: '2' })])`
+ * **WARNING**: Calling e.g.
+ * `Promise.all([setAttributes({ a: '1' }), setAttributes({ a: '2' })])`
  * is not guaranteed to be ordered consistently, but the equivalent
  * sequential `.then()` chain is.
  *
  * @example
  * ```ts
- * import { experimental_setAttributes } from 'workflow';
+ * import { setAttributes } from 'workflow';
  *
  * export async function myWorkflow() {
  *   'use workflow';
- *   await experimental_setAttributes({ phase: 'init' });
+ *   await setAttributes({ phase: 'init' });
  *   // ... work ...
- *   await experimental_setAttributes({ phase: 'done', orderId: 'ord_123' });
- *   await experimental_setAttributes({ orderId: undefined }); // remove
+ *   await setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await setAttributes({ orderId: undefined }); // remove
  * }
  * ```
  *
  * @example Framework / library code writing into the reserved namespace.
  * ```ts
- * await experimental_setAttributes(
+ * await setAttributes(
  *   { '$agent.kind': 'durable-agent' },
  *   { allowReservedAttributes: true }
  * );
  * ```
  */
-export declare function experimental_setAttributes(attrs: Record<string, string | undefined>, options?: ExperimentalSetAttributesOptions): Promise<void>;
+export declare function setAttributes(attrs: Record<string, string | undefined>, options?: SetAttributesOptions): Promise<void>;
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export declare const experimental_setAttributes: typeof setAttributes;
 //# sourceMappingURL=set-attributes.d.ts.map

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

@@ -1 +1 @@
-import{i as e}from"../../_chunks/workflow/dist-CttsoN4D.js";import{c as t,i as n}from"../../_chunks/workflow/dist-DpDDcpTl.js";import{An as r,En as i,On as a,Tn as o,dn as s,fn as c,nn as l,pn as u,rn as d,sn as f,t as p}from"../../_chunks/workflow/attribute-changes-BnKD8Y3m.js";import{t as m}from"../../_chunks/workflow/sleep-phozDCW8.js";import{t as h}from"../../_chunks/workflow/run-BSANnUPR.js";async function g(e,t={}){let r=p(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[u];if(!a)throw new n("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}d(l,h);function _(e){let t=globalThis[s];return t||i(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,_),t(e)}function v(t){let{respondWith:n,token:i,...a}=t??{};if(i!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let o;n!==void 0&&(o={respondWith:n});let s=_({...a,metadata:o,isWebhook:!0}),{url:c}=r();return s.url=e(c,{type:`webhook`,token:s.token}),s}function y(){function e(t,n){a(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return _(e)},resume:e}}function b(e={}){let{namespace:t}=e,n=globalThis[c](t);return Object.create(globalThis.WritableStream.prototype,{[f]:{value:n,writable:!1}})}function x(){o(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,x)}function S(){a(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,S)}export{n as FatalError,t as RetryableError,_ as createHook,v as createWebhook,y as defineHook,g as experimental_setAttributes,x as getStepMetadata,r as getWorkflowMetadata,b as getWritable,S as resumeHook,m as sleep};
+import{i as e}from"../../_chunks/workflow/dist-CttsoN4D.js";import{c as t,i as n}from"../../_chunks/workflow/dist-DpDDcpTl.js";import{An as r,Fn as i,Nn as a,_n as o,cn as s,fn as c,gn as l,jn as u,sn as d,t as f,vn as p}from"../../_chunks/workflow/attribute-changes-Dmf_myUv.js";import{t as m}from"../../_chunks/workflow/sleep-BkAHCD_s.js";import{t as h}from"../../_chunks/workflow/run-CL3mguvM.js";s(d,h);function g(e){let t=globalThis[l];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(e)}function _(t){let{respondWith:n,token:r,...a}=t??{};if(r!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let o;n!==void 0&&(o={respondWith:n});let s=g({...a,metadata:o,isWebhook:!0}),{url:c}=i();return s.url=e(c,{type:`webhook`,token:s.token}),s}function v(){function e(t,n){a(`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 r=f(e,t);if(r.length===0)return;let i=t.allowReservedAttributes===!0,a=globalThis[p];if(!a)throw new n("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}const b=y;function x(e={}){let{namespace:t}=e,n=globalThis[o](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,writable:!1}})}function S(){r(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,S)}function C(){a(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,C)}export{n as FatalError,t as RetryableError,g as createHook,_ as createWebhook,v as defineHook,b as experimental_setAttributes,S as getStepMetadata,i as getWorkflowMetadata,x as getWritable,C as resumeHook,y as setAttributes,m as sleep};

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

@@ -47,18 +47,18 @@ export declare const AnalyticsEventSchema: z.ZodObject<{
     eventId: z.ZodString;
     eventType: z.ZodEnum<{
         run_created: "run_created";
+        run_started: "run_started";
         run_completed: "run_completed";
         run_failed: "run_failed";
+        run_cancelled: "run_cancelled";
+        attr_set: "attr_set";
         step_created: "step_created";
         step_completed: "step_completed";
         step_failed: "step_failed";
         step_retrying: "step_retrying";
+        step_started: "step_started";
         hook_created: "hook_created";
         hook_received: "hook_received";
-        run_started: "run_started";
-        run_cancelled: "run_cancelled";
-        attr_set: "attr_set";
-        step_started: "step_started";
         hook_disposed: "hook_disposed";
         hook_conflict: "hook_conflict";
         wait_created: "wait_created";

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

@@ -1,37 +1,35 @@
 import { z } from '#compiled/zod/index.js';
 import type { PaginationOptions, ResolveData } from './shared.js';
-/**
- * Fields within eventData that hold ref/payload data per event type.
- * When resolveData is 'none', only these fields are stripped — all other
- * metadata (stepName, workflowName, etc.) is preserved.
- */
-export declare const EVENT_DATA_REF_FIELDS: Record<string, string[]>;
-/**
- * Strip ref/payload fields from eventData based on resolveData setting.
- * When resolveData is 'none', removes only large data fields (refs) from
- * eventData while preserving metadata like stepName, workflowName, etc.
- */
-export declare function stripEventDataRefs(event: Event, resolveData: ResolveData): Event;
 export declare const EventTypeSchema: z.ZodEnum<{
     run_created: "run_created";
+    run_started: "run_started";
     run_completed: "run_completed";
     run_failed: "run_failed";
+    run_cancelled: "run_cancelled";
+    attr_set: "attr_set";
     step_created: "step_created";
     step_completed: "step_completed";
     step_failed: "step_failed";
     step_retrying: "step_retrying";
+    step_started: "step_started";
     hook_created: "hook_created";
     hook_received: "hook_received";
-    run_started: "run_started";
-    run_cancelled: "run_cancelled";
-    attr_set: "attr_set";
-    step_started: "step_started";
     hook_disposed: "hook_disposed";
     hook_conflict: "hook_conflict";
     wait_created: "wait_created";
     wait_completed: "wait_completed";
 }>;
 export type EventType = z.infer<typeof EventTypeSchema>;
+declare const RunEventTypeSchema: z.ZodEnum<{
+    run_created: "run_created";
+    run_started: "run_started";
+    run_completed: "run_completed";
+    run_failed: "run_failed";
+    run_cancelled: "run_cancelled";
+}>;
+export type RunEventType = z.infer<typeof RunEventTypeSchema>;
+export declare const RUN_EVENT_TYPES: ("run_created" | "run_started" | "run_completed" | "run_failed" | "run_cancelled")[];
+export declare function isRunEventType(eventType: string): eventType is RunEventType;
 export declare const TerminalRunEventTypeSchema: z.ZodEnum<{
     run_completed: "run_completed";
     run_failed: "run_failed";
@@ -40,21 +38,101 @@ export declare const TerminalRunEventTypeSchema: z.ZodEnum<{
 export type TerminalRunEventType = z.infer<typeof TerminalRunEventTypeSchema>;
 export declare const TERMINAL_RUN_EVENT_TYPES: ("run_completed" | "run_failed" | "run_cancelled")[];
 export declare function isTerminalRunEventType(eventType: string): eventType is TerminalRunEventType;
+declare const StepEventTypeSchema: z.ZodEnum<{
+    step_created: "step_created";
+    step_completed: "step_completed";
+    step_failed: "step_failed";
+    step_retrying: "step_retrying";
+    step_started: "step_started";
+}>;
+export type StepEventType = z.infer<typeof StepEventTypeSchema>;
+export declare const STEP_EVENT_TYPES: ("step_created" | "step_completed" | "step_failed" | "step_retrying" | "step_started")[];
+export declare function isStepEventType(eventType: string): eventType is StepEventType;
+declare const TerminalStepEventTypeSchema: z.ZodEnum<{
+    step_completed: "step_completed";
+    step_failed: "step_failed";
+}>;
+export type TerminalStepEventType = z.infer<typeof TerminalStepEventTypeSchema>;
+export declare const TERMINAL_STEP_EVENT_TYPES: ("step_completed" | "step_failed")[];
+export declare function isTerminalStepEventType(eventType: string): eventType is TerminalStepEventType;
+declare const HookLifecycleEventTypeSchema: z.ZodEnum<{
+    hook_created: "hook_created";
+    hook_received: "hook_received";
+    hook_disposed: "hook_disposed";
+}>;
+export type HookLifecycleEventType = z.infer<typeof HookLifecycleEventTypeSchema>;
+export declare const HOOK_LIFECYCLE_EVENT_TYPES: ("hook_created" | "hook_received" | "hook_disposed")[];
+export declare function isHookLifecycleEventType(eventType: string): eventType is HookLifecycleEventType;
+declare const HookEventRequiringExistenceTypeSchema: z.ZodEnum<{
+    hook_received: "hook_received";
+    hook_disposed: "hook_disposed";
+}>;
+export type HookEventRequiringExistenceType = z.infer<typeof HookEventRequiringExistenceTypeSchema>;
+export declare const HOOK_EVENTS_REQUIRING_EXISTENCE: ("hook_received" | "hook_disposed")[];
+export declare function isHookEventRequiringExistence(eventType: string): eventType is HookEventRequiringExistenceType;
+declare const WaitEventTypeSchema: z.ZodEnum<{
+    wait_created: "wait_created";
+    wait_completed: "wait_completed";
+}>;
+export type WaitEventType = z.infer<typeof WaitEventTypeSchema>;
+export declare const WAIT_EVENT_TYPES: ("wait_created" | "wait_completed")[];
+export declare function isWaitEventType(eventType: string): eventType is WaitEventType;
+declare const ChildEntityCreationEventTypeSchema: z.ZodEnum<{
+    step_created: "step_created";
+    hook_created: "hook_created";
+    wait_created: "wait_created";
+}>;
+export type ChildEntityCreationEventType = z.infer<typeof ChildEntityCreationEventTypeSchema>;
+export declare const CHILD_ENTITY_CREATION_EVENT_TYPES: ("step_created" | "hook_created" | "wait_created")[];
+export declare function isChildEntityCreationEventType(eventType: string): eventType is ChildEntityCreationEventType;
+/**
+ * Field within eventData that carries the opaque user payload for event types
+ * that have one. V4 worlds split this field into the wire body while keeping
+ * the remaining eventData fields in metadata.
+ */
+export declare const EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE: {
+    readonly run_created: "input";
+    readonly run_started: "input";
+    readonly run_completed: "output";
+    readonly run_failed: "error";
+    readonly step_created: "input";
+    readonly step_started: "input";
+    readonly step_completed: "result";
+    readonly step_failed: "error";
+    readonly step_retrying: "error";
+    readonly hook_created: "metadata";
+    readonly hook_received: "payload";
+};
+export type EventDataPayloadField = (typeof EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE)[keyof typeof EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE];
+/**
+ * Fields within eventData that hold ref/payload data per event type.
+ * When resolveData is 'none', only these fields are stripped — all other
+ * metadata (stepName, workflowName, etc.) is preserved.
+ */
+export declare const EVENT_DATA_REF_FIELDS: Record<string, readonly EventDataPayloadField[]>;
+export declare function getEventDataRefFields(eventType: string): readonly string[];
+export declare function getEventDataPayloadField(eventType: string): EventDataPayloadField | undefined;
+/**
+ * Strip ref/payload fields from eventData based on resolveData setting.
+ * When resolveData is 'none', removes only large data fields (refs) from
+ * eventData while preserving metadata like stepName, workflowName, etc.
+ */
+export declare function stripEventDataRefs(event: Event, resolveData: ResolveData): Event;
 export declare const BaseEventSchema: z.ZodObject<{
     eventType: z.ZodEnum<{
         run_created: "run_created";
+        run_started: "run_started";
         run_completed: "run_completed";
         run_failed: "run_failed";
+        run_cancelled: "run_cancelled";
+        attr_set: "attr_set";
         step_created: "step_created";
         step_completed: "step_completed";
         step_failed: "step_failed";
         step_retrying: "step_retrying";
+        step_started: "step_started";
         hook_created: "hook_created";
         hook_received: "hook_received";
-        run_started: "run_started";
-        run_cancelled: "run_cancelled";
-        attr_set: "attr_set";
-        step_started: "step_started";
         hook_disposed: "hook_disposed";
         hook_conflict: "hook_conflict";
         wait_created: "wait_created";
@@ -164,6 +242,9 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"run_cancelled">;
+    eventData: z.ZodOptional<z.ZodObject<{
+        cancelReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"attr_set">;
@@ -196,6 +277,11 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     eventType: z.ZodLiteral<"step_completed">;
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
+        ttfs: z.ZodOptional<z.ZodNumber>;
+        stso: z.ZodOptional<z.ZodNumber>;
+        stepCount: z.ZodOptional<z.ZodNumber>;
+        eventCount: z.ZodOptional<z.ZodNumber>;
+        optimizations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stepName: z.ZodOptional<z.ZodString>;
         workflowName: z.ZodOptional<z.ZodString>;
         result: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
@@ -205,6 +291,11 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     eventType: z.ZodLiteral<"step_failed">;
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
+        ttfs: z.ZodOptional<z.ZodNumber>;
+        stso: z.ZodOptional<z.ZodNumber>;
+        stepCount: z.ZodOptional<z.ZodNumber>;
+        eventCount: z.ZodOptional<z.ZodNumber>;
+        optimizations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stepName: z.ZodOptional<z.ZodString>;
         error: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
@@ -226,6 +317,7 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         attempt: z.ZodOptional<z.ZodNumber>;
         workflowName: z.ZodOptional<z.ZodString>;
         input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        ownerMessageId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -310,6 +402,9 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     correlationId: z.ZodOptional<z.ZodString>;
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"run_cancelled">;
+    eventData: z.ZodOptional<z.ZodObject<{
+        cancelReason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"attr_set">;
@@ -342,6 +437,11 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventType: z.ZodLiteral<"step_completed">;
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
+        ttfs: z.ZodOptional<z.ZodNumber>;
+        stso: z.ZodOptional<z.ZodNumber>;
+        stepCount: z.ZodOptional<z.ZodNumber>;
+        eventCount: z.ZodOptional<z.ZodNumber>;
+        optimizations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stepName: z.ZodOptional<z.ZodString>;
         workflowName: z.ZodOptional<z.ZodString>;
         result: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
@@ -351,6 +451,11 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventType: z.ZodLiteral<"step_failed">;
     correlationId: z.ZodString;
     eventData: z.ZodObject<{
+        ttfs: z.ZodOptional<z.ZodNumber>;
+        stso: z.ZodOptional<z.ZodNumber>;
+        stepCount: z.ZodOptional<z.ZodNumber>;
+        eventCount: z.ZodOptional<z.ZodNumber>;
+        optimizations: z.ZodOptional<z.ZodArray<z.ZodString>>;
         stepName: z.ZodOptional<z.ZodString>;
         error: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
     }, z.core.$strip>;
@@ -372,6 +477,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         attempt: z.ZodOptional<z.ZodNumber>;
         workflowName: z.ZodOptional<z.ZodString>;
         input: z.ZodOptional<z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>>;
+        ownerMessageId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
@@ -428,7 +534,14 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     specVersion: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>>;
 export type Event = z.infer<typeof EventSchema>;
-export type HookCreatedEvent = z.infer<typeof HookCreatedEventSchema>;
+export type EventOfType<T extends EventType> = Extract<Event, {
+    eventType: T;
+}>;
+export type EventRequestOfType<T extends EventType> = Extract<AnyEventRequest, {
+    eventType: T;
+}>;
+export type HookCreatedEvent = EventOfType<'hook_created'>;
+export type HookCreatedEventRequest = EventRequestOfType<'hook_created'>;
 export type HookReceivedEvent = z.infer<typeof HookReceivedEventSchema>;
 export type HookConflictEvent = z.infer<typeof HookConflictEventSchema>;
 /**
@@ -436,6 +549,14 @@ export type HookConflictEvent = z.infer<typeof HookConflictEventSchema>;
  * @internal Use CreateEventRequest or RunCreatedEventRequest instead.
  */
 export type AnyEventRequest = z.infer<typeof CreateEventSchema>;
+type ChildEntityCreationEventRequest = EventRequestOfType<ChildEntityCreationEventType> | (EventRequestOfType<'step_started'> & {
+    eventData: {
+        stepName: string;
+        input: unknown;
+    };
+});
+/** Includes lazy step_started requests that create their step on demand. */
+export declare function isChildEntityCreationEvent(event: AnyEventRequest): event is ChildEntityCreationEventRequest;
 /**
  * Event request for creating a new workflow run.
  * Can be used with a client-generated runId or null for server-generated.

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

@@ -28,30 +28,7 @@ export declare const HookSchema: z.ZodObject<{
  * - specVersion >= 2: Uint8Array (binary devalue format)
  * - specVersion 1: unknown (legacy JSON format)
  */
-export type Hook = z.infer<typeof HookSchema> & {
-    /** The unique identifier of the workflow run this hook belongs to. */
-    runId: string;
-    /** The unique identifier of this hook within the workflow run. */
-    hookId: string;
-    /** The secret token used to reference this hook. */
-    token: string;
-    /** The owner ID (team or user) that owns this hook. */
-    ownerId: string;
-    /** The project ID this hook belongs to. */
-    projectId: string;
-    /** The environment (e.g., "production", "preview", "development") where this hook was created. */
-    environment: string;
-    /** Optional metadata associated with the hook, set when the hook was created. */
-    metadata?: SerializedData;
-    /** The timestamp when this hook was created. */
-    createdAt: Date;
-    /** The spec version when this hook was created. */
-    specVersion?: number;
-    /** Whether this hook is resumable via the public webhook endpoint. undefined = legacy (treated as true for backwards compat). */
-    isWebhook?: boolean;
-    /** Whether this hook is a system-managed hook (e.g., for abort signals). */
-    isSystem?: boolean;
-};
+export type Hook = z.infer<typeof HookSchema>;
 export interface CreateHookRequest {
     hookId: string;
     token: string;

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

@@ -4,7 +4,7 @@ export type * from './attributes.js';
 export { ATTRIBUTE_KEY_MAX_LENGTH, ATTRIBUTE_MAX_PER_RUN, ATTRIBUTE_VALUE_MAX_BYTES, AttributeChangeSchema, AttributeChangesSchema, AttributeValidationError, applyAttributeChanges, RESERVED_ATTRIBUTE_KEY_PREFIX, validateAttributeChanges, validateAttributeKey, validateAttributeValue, } from './attributes.js';
 export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envNumber, } from './env-config.js';
 export type * from './events.js';
-export { BaseEventSchema, CreateEventSchema, EVENT_DATA_REF_FIELDS, EventSchema, EventTypeSchema, HookCreatedEventSchema, isTerminalRunEventType, stripEventDataRefs, TERMINAL_RUN_EVENT_TYPES, TerminalRunEventTypeSchema, } from './events.js';
+export { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, EVENT_DATA_PAYLOAD_FIELD_BY_EVENT_TYPE, EVENT_DATA_REF_FIELDS, EventSchema, EventTypeSchema, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';
 export type * from './hooks.js';
 export { HookSchema } from './hooks.js';
 export type * from './interfaces.js';
@@ -22,7 +22,8 @@ export type { SpecVersion } from './spec-version.js';
 export { isLegacySpecVersion, requiresNewerWorld, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, } from './spec-version.js';
 export type * from './steps.js';
 export { isTerminalStepStatus, StepSchema, StepStatusSchema, TERMINAL_STEP_STATUSES, TerminalStepStatusSchema, } from './steps.js';
-export { DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS, DEFAULT_TIMESTAMP_THRESHOLD_MS, DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS, ulidToDate, validateUlidTimestamp, } from './ulid.js';
+export { DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS, DEFAULT_TIMESTAMP_THRESHOLD_MS, DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS, ulidToDate, validateUlidTimestamp, workflowRunIdSchema, } from './ulid.js';
+export type { WorkflowRunId } from './ulid.js';
 export type * from './waits.js';
 export { WaitSchema, WaitStatusSchema } from './waits.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -147,6 +147,16 @@ export interface Queue {
     }>;
     /**
      * Creates an HTTP queue handler for processing messages from a specific queue.
+     *
+     * `meta.messageId` SHOULD be stable across redeliveries of the same message
+     * (one ID per enqueued message, reused on every delivery attempt). The
+     * runtime's inline step ownership uses it as a liveness lease: the lazy
+     * `step_started` records the handling invocation's messageId, and only a
+     * delivery of that same message may re-execute the step before the
+     * ownership lease expires (crash recovery via queue redelivery). A World
+     * whose queue mints a fresh ID per delivery degrades gracefully — owner
+     * redeliveries fall back to the delayed-backstop path instead of executing
+     * immediately, adding recovery latency but never wedging or duplicating.
      */
     createQueueHandler(queueNamePrefix: QueuePrefix, handler: (message: unknown, meta: {
         attempt: number;

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

@@ -1,5 +1,5 @@
-import type { Queue } from './queue.js';
 import type { Storage } from './interfaces.js';
+import { type Queue } from './queue.js';
 /**
  * Re-enqueue all active (pending/running) workflow runs so they resume
  * processing after a world restart. The workflow handler is idempotent
@@ -8,6 +8,7 @@ import type { Storage } from './interfaces.js';
  * @param runs - Storage runs interface for listing active runs
  * @param enqueue - Queue's enqueue method
  * @param label - Log prefix for identifying the world implementation (e.g. "world-local")
+ * @param namespace - Optional queue namespace. Defaults to WORKFLOW_QUEUE_NAMESPACE.
  */
-export declare function reenqueueActiveRuns(runs: Storage['runs'], enqueue: Queue['queue'], label: string): Promise<void>;
+export declare function reenqueueActiveRuns(runs: Storage['runs'], enqueue: Queue['queue'], label: string, namespace?: string): Promise<void>;
 //# sourceMappingURL=recovery.d.ts.map

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

@@ -1,3 +1,12 @@
+import { z } from '#compiled/zod/index.js';
+/**
+ * A workflow run ID: the `wrun_` prefix followed by a 26-char ULID (minted
+ * client-side in core's `start()`). Validates the exact shape — prefix plus a
+ * well-formed ULID — rather than a loose length bound, so callers can't smuggle
+ * arbitrary strings through APIs that persist a run ID verbatim.
+ */
+export declare const workflowRunIdSchema: z.ZodTemplateLiteral<`wrun_${string}`>;
+export type WorkflowRunId = z.infer<typeof workflowRunIdSchema>;
 /**
  * Default threshold for ULID timestamps in the past (24 hours).
  *