eve 0.34.0 → 0.35.0

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

@@ -1,5 +1,9 @@
 import { z } from '#compiled/zod/index.js';
+import type { Hook } from './hooks.js';
+import type { StartedWorkflowRun, WorkflowRun } from './runs.js';
 import type { PaginationOptions, ResolveData } from './shared.js';
+import type { StartedStep, Step } from './steps.js';
+import type { Wait } from './waits.js';
 export declare const EventTypeSchema: z.ZodEnum<{
     run_created: "run_created";
     run_started: "run_started";
@@ -685,6 +689,38 @@ export interface CreateEventParams {
      * authoritative full reload, which is always correct.
      */
     stateCursor?: string;
+    /**
+     * How many events the writer held in its loaded log when it decided to write
+     * this one — equivalently, the slot it expects to land on minus one.
+     *
+     * Only meaningful against a World that declares
+     * `WorldCapabilities.slotEventIds`, where slots are dense and 1-based so a
+     * count and a position are the same number. Such a World attempts
+     * `eventCount + 1`, and on contention **bumps** to the next free slot and
+     * commits there anyway — a stale count never rejects a write. What it does
+     * instead is report: when the committed slot is higher than the one asked
+     * for, the events occupying the skipped slots come back on the success
+     * response in {@link EventResult.events} / `cursor` / `hasMore`, so the
+     * writer learns exactly what it had not seen.
+     *
+     * This supersedes the {@link stateUpdatedAt} / {@link stateEventCount} /
+     * {@link stateCursor} triple for slot Worlds. That triple approximates a
+     * position with a ULID-time watermark plus a count of events at or below it,
+     * which is why a *complete but stale* prefix passes it: every event the
+     * writer holds is at or below its own watermark, so the count matches and no
+     * fence fires. A dense position has no such blind spot. Worlds without slots
+     * ignore this field and keep using the triple.
+     *
+     * A batch of writes issued from one snapshot starts from the same
+     * `eventCount`; they land on consecutive slots in whatever order the World
+     * serializes them, which is why they can stay a parallel fan-out instead of
+     * a chain of round-trips. The count a given write sends is the writer's
+     * position *at that moment*, so it advances mid-batch as reported events are
+     * folded back into the loaded log: a write issued after a sibling's
+     * bump-and-report already holds the slots that report named, and asks for a
+     * slot above them.
+     */
+    eventCount?: number;
     /**
      * Timestamp for when the event occurred on the client side. Worlds that
      * support this can persist it separately from `createdAt`, which represents
@@ -704,21 +740,23 @@ export interface CreateEventParams {
      * on the resulting {@link EventResult}, the first page of events written
      * strictly after this cursor (via `events`/`cursor`/`hasMore`) — the
      * same page an `events.list({ cursor: sinceCursor, sortOrder: 'asc' })`
-     * call would return immediately after this write. The inline runtime
-     * loop uses this to skip a redundant `events.list` round-trip between
-     * sequential steps: instead of re-reading its own just-written events
-     * (and any events interleaved in-band, such as `hook_received`), it
-     * consumes the authoritative delta the write already had to compute.
+     * call would return immediately after this write. Outside turbo mode the
+     * runtime sets this on every write it makes from the orchestrator loop
+     * and folds any returned delta into its in-memory log, so each write
+     * carries the log forward and the loop reads it back for free: instead of
+     * re-reading its own just-written events (and any events interleaved
+     * in-band, such as `hook_received`), it consumes the authoritative delta
+     * the write already had to compute. Turbo mode does not set it — the
+     * point there is to keep the first invocation's writes as cheap as
+     * possible, and it has no loaded log to extend.
      *
      * 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
      * further page exists. A World MAY return a single page and set
-     * `hasMore: true` rather than paginating to exhaustion — the runtime
-     * does not consume a truncated delta, it falls back to a full
-     * incremental fetch whenever `hasMore` is true. (For that reason a step
-     * body emitting more in-band events than one page silently bypasses this
-     * fast path, which is correct but forgoes the saved round-trip.)
+     * `hasMore: true` rather than paginating to exhaustion. The runtime
+     * consumes that page and continues from its cursor, so it never reads the
+     * returned prefix again.
      * Returning these fields at all is OPTIONAL — a World that omits them is
      * fully supported; the runtime falls back to `events.list`. This
      * preserves the same divergence guarantees as the fetch path because the
@@ -741,7 +779,7 @@ export interface CreateEventParams {
      * option end-to-end (cf. {@link sinceCursor}) so the single name greps
      * across the SDK and the backend.
      */
-    skipPreload?: boolean;
+    skipPreload?: true;
     /**
      * Replay-log preload opt-in (advisory) — the `hook_received` dual of
      * {@link skipPreload}. Set only by the queue consumer's idempotent
@@ -785,19 +823,34 @@ export interface CreateEventParams {
  *
  * Note: `event` is optional to support legacy runs where event storage is skipped.
  */
-export interface EventResult {
+export type EventResult<T extends EventType = EventType> = {
     /** The created event (optional for legacy compatibility) */
     event?: Event;
     /** The workflow run entity (for run_* events) */
-    run?: import('./runs.js').WorkflowRun;
+    run?: WorkflowRun;
     /** The step entity (for step_* events) */
-    step?: import('./steps.js').Step;
+    step?: Step;
     /** The hook entity (for hook_created events) */
-    hook?: import('./hooks.js').Hook;
+    hook?: Hook;
     /** The wait entity (for wait_created/wait_completed events) */
-    wait?: import('./waits.js').Wait;
+    wait?: Wait;
+    /**
+     * Lazy step start: set to `true` only when a `step_started` event with
+     * step-creation data atomically *created* the step on this call (the
+     * caller won the create-claim), as opposed to transitioning a step that
+     * already existed. The owned-inline runtime path uses this as the
+     * exactly-once ownership signal — it runs the step body inline only when
+     * it created the step, so a concurrent handler that lost the create race
+     * (and gets `EntityConflictError`/skipped) never double-executes. Absent
+     * (undefined) on the legacy path and from older servers/worlds, which is
+     * the safe default (treated as "not the lazy creator").
+     */
+    stepCreated?: true;
+    /** Server-owned max event count for the run (run-lifecycle responses); the runtime enforces it. */
+    maxEvents?: number;
+} & ({
     /**
-     * Events with data resolved. Three producers populate this:
+     * Events with data resolved. Four 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.
@@ -810,32 +863,36 @@ export interface EventResult {
      *   log through the canonical `hook_received`, so the lazy hook queue
      *   consumer can skip both the `run_started` write and the initial
      *   `events.list`.
+     * - On any response from a slot-allocating World (see
+     *   `WorldCapabilities.slotEventIds`) whose committed slot came out
+     *   higher than the one {@link CreateEventParams.eventCount} asked for:
+     *   the events occupying the slots that were skipped over, in slot
+     *   order. This is the "report" half of bump-and-report — the write
+     *   succeeded, and these are the events the writer had not seen when it
+     *   decided to make it.
      */
-    events?: Event[];
+    events: Event[];
     /** Pagination cursor for `events`, matching events.list semantics. */
-    cursor?: string | null;
+    cursor: string | null;
     /** Whether additional event pages are available for `events`. */
-    hasMore?: boolean;
-    /**
-     * Lazy step start: set to `true` only when a `step_started` event with
-     * step-creation data atomically *created* the step on this call (the
-     * caller won the create-claim), as opposed to transitioning a step that
-     * already existed. The owned-inline runtime path uses this as the
-     * exactly-once ownership signal — it runs the step body inline only when
-     * it created the step, so a concurrent handler that lost the create race
-     * (and gets `EntityConflictError`/skipped) never double-executes. Absent
-     * (undefined) on the legacy path and from older servers/worlds, which is
-     * the safe default (treated as "not the lazy creator").
-     */
-    stepCreated?: boolean;
-    /** Server-owned max event count for the run (run-lifecycle responses); the runtime enforces it. */
-    maxEvents?: number;
-}
+    hasMore: boolean;
+} | {
+    events?: undefined;
+    cursor?: undefined;
+    hasMore?: undefined;
+}) & (T extends 'run_created' ? {
+    run: WorkflowRun;
+} : T extends 'run_started' ? {
+    run: StartedWorkflowRun;
+} : T extends 'step_started' ? {
+    step: StartedStep;
+} : unknown);
 export interface GetEventParams {
     resolveData?: ResolveData;
 }
 export interface ListEventsParams {
     runId: string;
+    /** Omit `limit` to return every remaining event. */
     pagination?: PaginationOptions;
     resolveData?: ResolveData;
 }

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

@@ -2,7 +2,7 @@ export type * from './analytics.js';
 export { 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, AttributeValidationError, applyAttributeChanges, PARENT_RUN_ID_ATTRIBUTE, RESERVED_ATTRIBUTE_KEY_PREFIX, ROOT_RUN_ID_ATTRIBUTE, validateAttributeChanges, validateAttributeKey, validateAttributeValue, } from './attributes.js';
-export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envNumber, } from './env-config.js';
+export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envNumber, getMaxEventsPerRun, } from './env-config.js';
 export type * 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';
@@ -18,8 +18,9 @@ export { LegacySerializedDataSchemaV1, SerializedDataSchema, } from './serializa
 export type * from './shared.js';
 export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoResponse, } from './shared.js';
 export { PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
+export { EVENT_ID_BODY_LENGTH, EVENT_ID_PREFIX, eventIdToSlot, FIRST_EVENT_SLOT, isSlotBody, isSlotEventId, MAX_EVENT_SLOT, slotToEventId, } from './slot-identity.js';
 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 { isLegacySpecVersion, requiresNewerWorld, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_MAX_SUPPORTED, SPEC_VERSION_SUPPORTS_ATTRIBUTES, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_COMPRESSION, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from './spec-version.js';
 export type * from './steps.js';
 export { isTerminalStepStatus, StepSchema, StepStatusSchema, TERMINAL_STEP_STATUSES, TerminalStepStatusSchema, } from './steps.js';
 export type { WorkflowRunId } from './ulid.js';

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

@@ -178,7 +178,7 @@ export interface Storage {
          * @param params - Optional parameters for event creation
          * @returns Promise resolving to the created event and run entity
          */
-        create(runId: string | null, data: RunCreatedEventRequest, params?: CreateEventParams): Promise<EventResult>;
+        create<T extends RunCreatedEventRequest>(runId: string | null, data: T, params?: CreateEventParams): Promise<EventResult<T['eventType']>>;
         /**
          * Create an event for an existing workflow run and atomically update the entity.
          * Returns both the event and the affected entity (run/step/hook).
@@ -188,7 +188,7 @@ export interface Storage {
          * @param params - Optional parameters for event creation
          * @returns Promise resolving to the created event and affected entity
          */
-        create(runId: string, data: CreateEventRequest, params?: CreateEventParams): Promise<EventResult>;
+        create<T extends CreateEventRequest>(runId: string, data: T, params?: CreateEventParams): Promise<EventResult<T['eventType']>>;
         get(runId: string, eventId: string, params?: GetEventParams): Promise<Event>;
         list(params: ListEventsParams): Promise<PaginatedResponse<Event>>;
         listByCorrelationId(params: ListEventsByCorrelationIdParams): Promise<PaginatedResponse<Event>>;
@@ -305,6 +305,29 @@ export interface WorldCapabilities {
      * fail ordinary runs after a version bump.
      */
     deploymentAffinity?: boolean;
+    /**
+     * The World allocates **slot-numbered** event ids: `evnt_` plus the event's
+     * dense, 1-based position in its run's log, zero-padded to 26 characters
+     * (see `slot-identity.ts`). Two guarantees come with it, and the runtime
+     * relies on both:
+     *
+     * - **Density.** A run's slots are contiguous from 1, so the number of
+     *   events a reader holds *is* the position of the last one. That is what
+     *   makes {@link CreateEventParams.eventCount} a complete statement of the
+     *   writer's snapshot, where the `stateUpdatedAt` / `stateEventCount`
+     *   watermark pair could only approximate it.
+     * - **Bump and report.** A create never fails because its requested slot is
+     *   taken. The World advances to the next free slot, commits there, and
+     *   returns the events occupying the slots it skipped over on the success
+     *   response (see {@link EventResult.events}). The writer learns its
+     *   snapshot was stale without the write being rejected.
+     *
+     * A run's scheme is pinned by the run, not by this flag: it is readable off
+     * the shape of the run's own first event id, so a World that turns slots on
+     * keeps replaying its existing ULID-numbered runs unchanged. The capability
+     * only says what *new* runs get.
+     */
+    slotEventIds?: boolean;
 }
 /**
  * The "World" interface represents how Workflows are able to communicate with the outside world.
@@ -332,27 +355,6 @@ export interface World extends Queue, Streamer, Storage {
      * "unsupported": runtime optimizations gated on a capability fail closed.
      */
     capabilities?: WorldCapabilities;
-    /**
-     * Whether calling `process.exit(1)` from a queue handler is observed by
-     * the World as a delivery failure that will be retried.
-     *
-     * Set to `true` for worlds running inside a managed serverless platform
-     * (e.g. `world-vercel`) where the platform fails the invocation when the
-     * function process exits non-zero, and the queue redelivers the message
-     * via a separate fresh invocation.
-     *
-     * Set to `false` (the default) for in-process worlds (e.g. `world-local`,
-     * dev servers) where calling `process.exit()` would terminate the host
-     * process — including the user's `pnpm dev` — without producing a
-     * redelivery. Such worlds should instead surface failures via the event
-     * log and return normally.
-     *
-     * The core runtime reads this when deciding how to handle an exhausted
-     * replay budget: when `true` it exits so the queue redelivers; when
-     * `false` it writes `run_failed` best-effort and returns. See
-     * `packages/core/src/runtime/replay-budget.ts`.
-     */
-    processExitTriggersQueueRedelivery?: boolean;
     /**
      * Absolute wall-clock time when the current function invocation will be
      * terminated by the hosting platform, if known. Used to optimize runtime behavior.

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

@@ -73,6 +73,7 @@ export declare const HookResumeInputSchema: z.ZodObject<{
     token: z.ZodString;
     payload: z.ZodUnknown;
     payloadDigest: z.ZodString;
+    deploymentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type HookResumeInput = z.infer<typeof HookResumeInputSchema>;
 export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
@@ -104,6 +105,7 @@ export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
         token: z.ZodString;
         payload: z.ZodUnknown;
         payloadDigest: z.ZodString;
+        deploymentId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type WorkflowInvokePayload = z.infer<typeof WorkflowInvokePayloadSchema>;
@@ -167,6 +169,7 @@ export declare const QueuePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
         token: z.ZodString;
         payload: z.ZodUnknown;
         payloadDigest: z.ZodString;
+        deploymentId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
 }, z.core.$strip>]>;
 export type QueuePayload = z.infer<typeof QueuePayloadSchema>;
@@ -211,6 +214,7 @@ export interface Queue {
     }>;
     /**
      * Creates an HTTP queue handler for processing messages from a specific queue.
+     * A rejected handler must retry the same message with an incremented attempt.
      *
      * `meta.messageId` SHOULD be stable across redeliveries of the same message
      * (one ID per enqueued message, reused on every delivery attempt). The

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

@@ -127,6 +127,10 @@ export declare const WorkflowRunSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     completedAt: z.ZodCoercedDate<unknown>;
 }, z.core.$strip>], "status">;
 export type WorkflowRun = z.infer<typeof WorkflowRunSchema>;
+/** A workflow run with its first start time materialized. */
+export type StartedWorkflowRun = WorkflowRun & {
+    startedAt: Date;
+};
 /**
  * WorkflowRun with input/output fields excluded (when resolveData='none').
  * Used for listing runs without fetching the full serialized data.

package/dist/src/compiled/@workflow/world/slot-identity.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Slot-based event identity.
+ *
+ * An event id is `evnt_` followed by 26 characters. Historically that body was
+ * a ULID; a World that allocates *slots* instead writes the event's dense
+ * 1-based position in its run's log, as a zero-padded decimal.
+ *
+ * The padding is what makes this a drop-in change rather than a format break.
+ * Decimal digits are a subset of Crockford base32, and every id is still
+ * exactly 26 characters, so existing ULID validators accept a slot id,
+ * lexicographic ordering still matches creation order (fixed width, so string
+ * order is numeric order), and `eid:` cursors and range fences keep working
+ * untouched.
+ *
+ * The one thing that does *not* survive: a slot id's leading characters are
+ * zeros, so decoding it as a ULID timestamp yields the Unix epoch. Nothing may
+ * derive a time from an event id without first ruling out a slot id — see
+ * {@link isSlotBody} and the guard in `ulidToDate`.
+ */
+/** Characters in an event id body, ULID or slot alike. */
+export declare const EVENT_ID_BODY_LENGTH = 26;
+/** First slot in a run's log. Slots are 1-based and dense. */
+export declare const FIRST_EVENT_SLOT = 1;
+/**
+ * Largest representable slot. Bounded by JavaScript's safe-integer range
+ * rather than by the 16 significant digits the format allows, so a parsed slot
+ * is always exact.
+ */
+export declare const MAX_EVENT_SLOT: number;
+/** Canonical prefix for event ids. */
+export declare const EVENT_ID_PREFIX = "evnt_";
+/**
+ * Whether a 26-character event id *body* is a slot rather than a ULID.
+ *
+ * Takes the body, not the prefixed id, because the same test applies to event
+ * ids however they are spelled (`evnt_`, the legacy `wevt_`, or bare).
+ */
+export declare function isSlotBody(body: string): boolean;
+/** Whether a (possibly prefixed) event id is slot-numbered. */
+export declare function isSlotEventId(eventId: string): boolean;
+/**
+ * Formats a slot as a prefixed event id.
+ *
+ * @throws if the slot is outside the representable range — a caller that
+ * overflows must fail loudly rather than mint an id that sorts wrong.
+ */
+export declare function slotToEventId(slot: number): string;
+/**
+ * Reads the slot out of a (possibly prefixed) event id, or null when the id is
+ * not slot-numbered.
+ */
+export declare function eventIdToSlot(eventId: string): number | null;
+//# sourceMappingURL=slot-identity.d.ts.map

package/dist/src/compiled/@workflow/world/spec-version.d.ts

@@ -26,11 +26,46 @@ export declare const SPEC_VERSION_SUPPORTS_ATTRIBUTES: SpecVersion;
  * `requiresNewerWorld()` instead of failing on individual payloads.
  */
 export declare const SPEC_VERSION_SUPPORTS_COMPRESSION: SpecVersion;
+/**
+ * Runs at this spec version get slot-numbered event ids: `evnt_` followed by a
+ * zero-padded decimal position, dense and contiguous from 1 within one run.
+ *
+ * This exists for Worlds that cannot read a run's scheme off its own storage.
+ * `world-local` and `world-postgres` own the counter that mints the ids, so
+ * they know per run which scheme it started under. `world-vercel` writes
+ * through an API whose allocator has to make that decision on each request,
+ * and the spec version stamped on `run_created` is what carries it. A run
+ * created before the backend adopted slots stays on ULIDs for its whole life
+ * because its stamped version is below this one.
+ */
+export declare const SPEC_VERSION_SUPPORTS_SLOT_IDENTITY: SpecVersion;
 /**
  * Current spec version (event-sourced architecture with native attributes
  * and compressed payloads).
+ *
+ * Deliberately NOT bumped for slot-numbered event ids. Slot numbering is a
+ * property of a run's whole log rather than of an individual event, and it is
+ * already self-describing: a run's scheme is readable from the shape of its
+ * own first event id (see `isSlotEventId`), so a World that owns its own id
+ * allocation needs no version negotiation to pin one. Bumping this constant
+ * would stamp the new version on every World
+ * including ones that have not adopted slots yet, which is exactly the
+ * cross-version breakage the pin exists to avoid. A World that does allocate
+ * slots declares the higher version itself (see `world-vercel`), and
+ * `SPEC_VERSION_MAX_SUPPORTED` is what keeps this reader from rejecting the
+ * runs it produces.
  */
 export declare const SPEC_VERSION_CURRENT: SpecVersion;
+/**
+ * The highest spec version this SDK can read.
+ *
+ * Distinct from `SPEC_VERSION_CURRENT`, which is the *default* a World stamps
+ * on runs it creates. A World may declare a higher version than the default,
+ * so the "was this run made by a newer SDK?" test has to be against the
+ * ceiling: comparing against the default would make the SDK reject runs its
+ * own adapters just created.
+ */
+export declare const SPEC_VERSION_MAX_SUPPORTED: SpecVersion;
 /**
  * Check if a spec version is legacy (<= SPEC_VERSION_LEGACY or undefined).
  * Legacy runs require different handling - they use direct entity mutation
@@ -45,7 +80,7 @@ export declare const SPEC_VERSION_CURRENT: SpecVersion;
  */
 export declare function isLegacySpecVersion(v: number | undefined | null): boolean;
 /**
- * Check if a spec version requires a newer world (> SPEC_VERSION_CURRENT).
+ * Check if a spec version requires a newer world (> SPEC_VERSION_MAX_SUPPORTED).
  * This happens when a run was created by a newer SDK version.
  *
  * @param v - The spec version number, or undefined/null for legacy runs

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

@@ -47,6 +47,10 @@ export type TerminalStepStatus = z.infer<typeof TerminalStepStatusSchema>;
 export declare const TERMINAL_STEP_STATUSES: ("completed" | "failed" | "cancelled")[];
 export declare function isTerminalStepStatus(status: string): status is TerminalStepStatus;
 export type Step = z.infer<typeof StepSchema>;
+/** A step with its first start time materialized. */
+export type StartedStep = Step & {
+    startedAt: Date;
+};
 /**
  * Step with input/output fields excluded (when resolveData='none').
  * Used for listing steps without fetching the full serialized data.

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

@@ -26,6 +26,12 @@ export declare const DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS: number;
 export declare const DEFAULT_TIMESTAMP_THRESHOLD_MS: number;
 /**
  * Extracts a Date from a ULID string, or null if the string is not a valid ULID.
+ *
+ * A slot-numbered event id is syntactically a valid ULID (26 zero-padded
+ * decimal digits are all Crockford characters) whose timestamp component is
+ * zero, so decoding one would silently yield the Unix epoch. Slots carry no
+ * time at all, so this returns null for them and callers fall back to a real
+ * `createdAt`. See `slot-identity.ts`.
  */
 export declare function ulidToDate(maybeUlid: string): Date | null;
 /**