eve 0.67.1 → 0.67.2

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

@@ -350,7 +350,11 @@ export declare function createForwardedWritable<W = any>({ global, ops, runId, n
 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 external hydration. Defaults preserve live, eager hydration. @internal */
 type ExternalReviverOptions = {
-    /** Defer readable stream I/O until consumption, including nested streams. */
+    /**
+     * Defer readable stream I/O until consumption, including nested streams.
+     * Writable streams still construct their forwarding pipe and lock poller
+     * during hydration; callers must drain `ops` even for unused writables.
+     */
     lazyStreams?: boolean;
     /** Set false for terminal reporting: revive only the persisted abort snapshot. */
     liveAbortSignals?: boolean;
@@ -549,9 +553,10 @@ export declare function dehydrateRunError(value: unknown, _runId: string, key: P
  * @param ops - Promise array for stream operations
  * @param global - Global object for deserialization context
  * @param extraRevivers - Additional revivers for custom types
+ * @param options - External hydration policy, including lazy readable streams
  * @returns The hydrated thrown value, ready to be consumed by the client
  */
-export declare function hydrateRunError(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>): Promise<unknown>;
+export declare function hydrateRunError(value: Uint8Array | unknown, runId: string, key: PayloadKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, options?: ExternalReviverOptions): Promise<unknown>;
 /**
  * Called from the workflow handler when replaying the event log of a `step_completed` event.
  * Hydrates the return value of a step from the database.

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

@@ -1 +1 @@
-import{An as e,Bn as t,Dn as n,En as r,Fn as i,In as a,Ln as o,Nn as s,On as c,Pn as l,Rn as u,jn as d,kn as f,zn as p}from"../../_chunks/workflow/logger-BCEj9caG.js";import{A as m,C as h,D as g,E as _,F as v,I as y,J as b,L as x,M as S,N as C,O as w,P as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,q as W,r as G,s as K,t as q,u as J,v as Y,w as X,x as Z,y as Q}from"../../_chunks/workflow/serialization-CJ265vSe.js";export{q as FRAMED_STREAM_MAX_RECONNECTS,V as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,p as SerializationFormat,G as WorkflowServerReadableStream,I as WorkflowServerWritableStream,r as aesKeyOf,k as cancelAbortReaders,W as compress,H as createForwardedWritable,K as createReconnectingFramedStream,i as decodeFormatPrefix,b as decompress,n as decrypt,j as dehydrateRunError,z as dehydrateStepArguments,J as dehydrateStepError,M as dehydrateStepReturnValue,N as dehydrateWorkflowArguments,U as dehydrateWorkflowReturnValue,c as deriveRunPayloadKeys,B as deserializePreparedReplayPayload,F as deserializePreparedStepError,a as encodeWithFormatPrefix,f as encrypt,P as getByteFramingStream,O as getByteUnframingStream,Y as getCommonRevivers,Q as getDeserializeStream,A as getExternalReducers,Z as getExternalRevivers,E as getForwardedWritableEncryptionKey,h as getRunReadableStream,X as getSerializeStream,D as getStreamType,_ as getWorkflowReducers,g as getWorkflowRevivers,w as hydrateRunError,R as hydrateStepArguments,m as hydrateStepError,L as hydrateStepReturnValue,S as hydrateWorkflowArguments,C as hydrateWorkflowReturnValue,o as isEncrypted,t as isFormatPrefix,e as isRunPayloadKeys,d as isSealTarget,T as maybeDecrypt,v as maybeEncrypt,u as peekFormatPrefix,y as prepareReplayPayload,s as runPayloadKeys,l as sealTo,x as tagForwardedWritableTarget};
+import{Bn as e,Fn as t,Gn as n,Hn as r,In as i,Mn as a,Nn as o,Pn as s,Rn as c,Un as l,Vn as u,Wn as d,jn as f,zn as p}from"../../_chunks/workflow/logger-D4GJNTk4.js";import{A as m,C as h,D as g,E as _,F as v,I as y,J as b,L as x,M as S,N as C,O as w,P as T,S as E,T as D,_ as O,a as k,b as A,c as j,d as M,f as N,g as P,h as F,i as I,j as L,k as R,l as z,m as B,n as V,o as H,p as U,q as W,r as G,s as K,t as q,u as J,v as Y,w as X,x as Z,y as Q}from"../../_chunks/workflow/serialization-CNIYl1D3.js";export{q as FRAMED_STREAM_MAX_RECONNECTS,V as FRAMED_STREAM_MAX_TOTAL_RECONNECTS,d as SerializationFormat,G as WorkflowServerReadableStream,I as WorkflowServerWritableStream,f as aesKeyOf,k as cancelAbortReaders,W as compress,H as createForwardedWritable,K as createReconnectingFramedStream,e as decodeFormatPrefix,b as decompress,a as decrypt,j as dehydrateRunError,z as dehydrateStepArguments,J as dehydrateStepError,M as dehydrateStepReturnValue,N as dehydrateWorkflowArguments,U as dehydrateWorkflowReturnValue,o as deriveRunPayloadKeys,B as deserializePreparedReplayPayload,F as deserializePreparedStepError,u as encodeWithFormatPrefix,s as encrypt,P as getByteFramingStream,O as getByteUnframingStream,Y as getCommonRevivers,Q as getDeserializeStream,A as getExternalReducers,Z as getExternalRevivers,E as getForwardedWritableEncryptionKey,h as getRunReadableStream,X as getSerializeStream,D as getStreamType,_ as getWorkflowReducers,g as getWorkflowRevivers,w as hydrateRunError,R as hydrateStepArguments,m as hydrateStepError,L as hydrateStepReturnValue,S as hydrateWorkflowArguments,C as hydrateWorkflowReturnValue,r as isEncrypted,n as isFormatPrefix,t as isRunPayloadKeys,i as isSealTarget,T as maybeDecrypt,v as maybeEncrypt,l as peekFormatPrefix,y as prepareReplayPayload,c as runPayloadKeys,p as sealTo,x as tagForwardedWritableTarget};

package/dist/src/compiled/@workflow/core/telemetry/semantic-conventions.d.ts

@@ -396,6 +396,35 @@ export declare const WorkflowDeploymentMismatchRetryCount: (value: number) => {
 export declare const WorkflowDeploymentMismatchRecovered: (value: boolean) => {
     [k: string]: boolean;
 };
+/** The spec version `start()` stamped on the new run. */
+export declare const WorkflowRunSpecVersion: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Where the stamped spec version came from: the caller's own World
+ * (`same-deployment`), the caller (`explicit`), or, for a cross-deployment
+ * start, the target's capability probe (`probe`, `probe-unversioned`,
+ * `probe-malformed`) or a
+ * fallback when it did not answer (`probe-miss`, `no-probe-channel`).
+ */
+export declare const WorkflowRunSpecVersionSource: (value: string) => {
+    [k: string]: string;
+};
+/** Round-trip time of a cross-deployment capability probe that answered. */
+export declare const WorkflowCapabilityProbeLatencyMs: (value: number) => {
+    [k: string]: number;
+};
+/**
+ * Whether a cross-deployment start reused an earlier answer from the same
+ * target deployment instead of probing it again.
+ */
+export declare const WorkflowCapabilityProbeCached: (value: boolean) => {
+    [k: string]: boolean;
+};
+/** Why a cross-deployment capability probe failed (e.g. a timeout). */
+export declare const WorkflowCapabilityProbeError: (value: string) => {
+    [k: string]: string;
+};
 /** Token identifying a specific hook */
 export declare const HookToken: (value: string) => {
     [k: string]: string;

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

@@ -1,4 +1,5 @@
 export declare function getErrorName(v: unknown): string;
+export declare function getErrorMessage(v: unknown): string;
 export declare function getErrorStack(v: unknown): string;
 /**
  * Summarize the `cause` chain hanging off a thrown value, one link per line,

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

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

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

@@ -1 +1 @@
-import{d as e,i as t}from"../../_chunks/workflow/dist-BfMqXLK3.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{X as r,Y as i,ft as a,mt as o,pt as s,st as c}from"../../_chunks/workflow/serialization-CJ265vSe.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-DzJovO_f.js";import{t as m}from"../../_chunks/workflow/sleep-CBn94Ayv.js";import{t as h}from"../../_chunks/workflow/run-CA5wWV2S.js";r(i,h);function g(e){let t=globalThis[a];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(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}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}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,n={}){let r=p(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new t("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,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{t as FatalError,e 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{d as e,i as t}from"../../_chunks/workflow/dist-CaNNONeg.js";import{i as n}from"../../_chunks/workflow/workflow-routes-CwqB063q.js";import{X as r,Y as i,ft as a,mt as o,pt as s,st as c}from"../../_chunks/workflow/serialization-CNIYl1D3.js";import{c as l,i as u,o as d,r as f,t as p}from"../../_chunks/workflow/attribute-changes-D721NpZv.js";import{t as m}from"../../_chunks/workflow/sleep-DFKgN7UG.js";import{t as h}from"../../_chunks/workflow/run-5DmiMN9b.js";r(i,h);function g(e){let t=globalThis[a];return t||u(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,g),t(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}=l();return o.url=n(s,{type:`webhook`,token:o.token}),o}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,n={}){let r=p(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new t("setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}function b(e={}){let{namespace:t}=e,n=globalThis[s](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,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{t as FatalError,e 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/index.d.ts

@@ -105,6 +105,17 @@ export declare class WorkflowWorldError extends WorkflowError {
  * ```
  */
 export declare class WorkflowRunFailedError extends WorkflowError {
+    /**
+     * `failed` is terminal, and a run's terminal state is immutable. This error
+     * is only ever thrown after a *successful* read of such a run, so re-running
+     * the read returns the same record and throws the same error. Marking it
+     * non-retryable is what stops the step executor from spending a retry budget
+     * on that when the read happens inside a step — a parent awaiting a child's
+     * `returnValue` — and then replacing this error with its retry-exhaustion
+     * wrapper. A read that *fails* throws something else and stays retryable.
+     * See `FatalError.is()`.
+     */
+    fatal: boolean;
     runId: string;
     /**
      * The high-level error category (e.g. USER_ERROR, RUNTIME_ERROR) for the
@@ -612,6 +623,8 @@ export declare class PreconditionFailedError extends WorkflowWorldError {
  * ```
  */
 export declare class WorkflowRunCancelledError extends WorkflowError {
+    /** Terminal and immutable, for the same reason as {@link WorkflowRunFailedError.fatal}. */
+    fatal: boolean;
     runId: string;
     constructor(runId: string);
     static is(value: unknown): value is WorkflowRunCancelledError;

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

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

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

@@ -1,7 +1,7 @@
 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 { EventsResolveData, PaginationOptions, ResolveData } from './shared.js';
 import type { StartedStep, Step } from './steps.js';
 import type { Wait } from './waits.js';
 export * from './event-metadata.js';
@@ -96,7 +96,7 @@ export declare function isChildEntityCreationEventType(eventType: string): event
  * 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 function stripEventDataRefs(event: Event, resolveData: EventsResolveData): Event;
 export declare const BaseEventSchema: z.ZodObject<{
     eventType: z.ZodEnum<{
         run_created: "run_created";
@@ -607,7 +607,17 @@ export type RunCreatedEventRequest = z.infer<typeof RunCreatedEventSchema>;
 export type CreateEventRequest = Exclude<AnyEventRequest, RunCreatedEventRequest>;
 export interface CreateEventParams {
     v1Compat?: boolean;
-    resolveData?: ResolveData;
+    /**
+     * `'skip-step-inputs'` applies only to the event-log page this create
+     * returns (the `sinceCursor` delta or a replay preload), never to the
+     * created `event` or the returned `step` entity, whose `input` is what step
+     * execution reads. See {@link EventsResolveData}.
+     *
+     * Code that forwards these params to an entity read (runs, steps, hooks,
+     * whose `resolveData` is a plain {@link ResolveData}) must map them with
+     * `entityResolveData()` first.
+     */
+    resolveData?: EventsResolveData;
     /**
      * Lazy hook resume idempotency key. Set only by `resumeHook()` when it
      * persists a `hook_received` event whose creation must be deduplicated
@@ -987,7 +997,7 @@ export interface ListEventsParams {
     runId: string;
     /** Omit `limit` to return every remaining event. */
     pagination?: PaginationOptions;
-    resolveData?: ResolveData;
+    resolveData?: EventsResolveData;
 }
 export interface ListEventsByCorrelationIdParams {
     correlationId: string;

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

@@ -19,10 +19,10 @@ export type { SerializedData } from './serialization.js';
 export { LegacySerializedDataSchemaV1, SerializedDataSchema, } from './serialization.js';
 export type * from './shared.js';
 export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoResponse, } from './shared.js';
-export { PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
+export { entityResolveData, PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
 export { EVENT_ID_BODY_LENGTH, EVENT_ID_PREFIX, eventIdToSlot, FIRST_EVENT_SLOT, isSlotBody, isSlotEventId, MAX_EVENT_SLOT, requireEventSlot, slotToEventId, } from './slot-identity.js';
 export type { SpecVersion } from './spec-version.js';
-export { isLegacySpecVersion, mintedSpecVersion, requiresNewerWorld, SEALED_LOG_ENV_VAR, 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_HOOK_FORCE_CLAIM, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, } from './spec-version.js';
+export { CAPABILITY_ONLY_SPEC_VERSIONS, crossesStructuralSpecVersion, isLegacySpecVersion, mintedSpecVersion, requiresNewerWorld, SEALED_LOG_ENV_VAR, 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_HOOK_FORCE_CLAIM, SPEC_VERSION_SUPPORTS_SEALED_LOG, SPEC_VERSION_SUPPORTS_SLOT_IDENTITY, STRUCTURAL_SPEC_VERSIONS, } 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

@@ -332,7 +332,8 @@ export interface Storage {
          * batch). Events outside this list keep their own ordering requirements:
          * a caller mixing a batch with single writes (hook or attribute events)
          * owns those barriers itself: the core runtime never batches a
-         * suspension that carries hook or attribute writes.
+         * suspension that carries attribute writes, and writes a suspension's
+         * hook events through the single path concurrently with its batch.
          */
         createBatch?(runId: string, events: BatchEventRequest[], params?: CreateEventBatchParams): Promise<EventBatchResult>;
         get(runId: string, eventId: string, params?: GetEventParams): Promise<Event>;

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

@@ -38,6 +38,30 @@ export type PaginatedResponse<T> = z.infer<ReturnType<typeof PaginatedResponseSc
  * - "all": Returns full data with complete input and output
  */
 export type ResolveData = 'none' | 'all';
+/**
+ * {@link ResolveData} for event-log reads, plus one mode for replay:
+ * - "skip-step-inputs": as "all", except that the World MAY leave `input` out
+ *   of `step_created` and `step_started` events. Workflow replay recomputes
+ *   step arguments by re-running workflow code and never reads the recorded
+ *   ones (a step takes its input from the `step_started` response or from
+ *   memory, never from the replay log), and for a workflow that passes
+ *   growing state into its steps those inputs are the part of the log that
+ *   grows quadratically.
+ *
+ * **A World MUST treat any value other than "none" as "all"** for everything
+ * it does not specifically implement. The runtime replays with
+ * "skip-step-inputs", so a World that tests `resolveData === 'all'` (reading
+ * the new value as "none") strips step results and breaks every replay, and
+ * one that validates against `['none', 'all']` rejects the read. Test
+ * `resolveData === 'none'`, or map with {@link entityResolveData}. The
+ * `@workflow/world-testing` suite checks this.
+ */
+export type EventsResolveData = ResolveData | 'skip-step-inputs';
+/**
+ * The {@link ResolveData} an {@link EventsResolveData} asks for on everything
+ * other than an event-log page's step inputs: `'skip-step-inputs'` is `'all'`.
+ */
+export declare function entityResolveData<T extends EventsResolveData | undefined>(resolveData: T): Exclude<T, 'skip-step-inputs'> | 'all';
 /**
  * A standard error schema shape for propogating errors from runs and steps
  */

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

@@ -166,6 +166,29 @@ export declare function mintedSpecVersion(env?: Record<string, string | undefine
  * everywhere.
  */
 export declare const SPEC_VERSION_MAX_SUPPORTED: SpecVersion;
+/**
+ * Spec versions whose only effect is to switch on capabilities of a run's
+ * reader and writer, which is the runtime executing it. A backend may raise
+ * a running run across these (to its executor's attested version, see
+ * `executorSpecVersion` on `run_started`), because nothing already in the
+ * run's log changes meaning.
+ *
+ * Every other version is STRUCTURAL: it changes how the log is laid out or
+ * read (event sourcing itself, slot-numbered event ids, sealed-log
+ * sequencing), so a run may only be moved across it before any event past
+ * `run_created` exists. That includes versions not listed here yet: an
+ * unclassified future version is structural by default, and adding a
+ * version constant without classifying it fails this package's tests.
+ */
+export declare const CAPABILITY_ONLY_SPEC_VERSIONS: ReadonlySet<number>;
+/** The structural spec versions; see {@link CAPABILITY_ONLY_SPEC_VERSIONS}. */
+export declare const STRUCTURAL_SPEC_VERSIONS: ReadonlySet<number>;
+/**
+ * Whether moving a run from spec version `from` up to `to` crosses a
+ * structural version, and so is only allowed while the run's log holds
+ * nothing but `run_created`. See {@link CAPABILITY_ONLY_SPEC_VERSIONS}.
+ */
+export declare function crossesStructuralSpecVersion(from: number, to: number): boolean;
 /**
  * Check if a spec version is legacy (<= SPEC_VERSION_LEGACY or undefined).
  * Legacy runs require different handling - they use direct entity mutation