eve 0.48.0 → 0.49.0

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

@@ -54,7 +54,7 @@ export declare class WorkflowError extends Error {
  * This is the catch-all error for world implementations. Specific,
  * well-known failure modes have dedicated error types (e.g.
  * EntityConflictError, RunExpiredError, ThrottleError). This error
- * covers everything else — validation failures, missing entities
+ * covers everything else: validation failures, missing entities
  * without a dedicated type, or unexpected HTTP errors from world-vercel.
  */
 export declare class WorkflowWorldError extends WorkflowError {
@@ -184,7 +184,7 @@ export declare class MaxEventsExceededError extends WorkflowError {
  * failure without poking through stacks.
  */
 export interface RuntimeDecryptionErrorContext {
-    /** The operation that failed — useful to tell encrypt vs decrypt apart. */
+    /** The operation that failed, useful to tell encrypt vs decrypt apart. */
     operation?: 'encrypt' | 'decrypt';
     /** Byte length of the input payload at the time of the failure. */
     byteLength?: number;
@@ -200,7 +200,7 @@ export interface RuntimeDecryptionErrorContext {
  * Thrown when the SDK's built-in AES-GCM encryption layer fails to encrypt
  * or decrypt a workflow payload.
  *
- * This is an internal SDK failure — user code never invokes the SDK's
+ * This is an internal SDK failure: user code never invokes the SDK's
  * encryption primitives directly. Common causes:
  *
  * - A ciphertext / auth tag mismatch, typically surfaced as the native Web
@@ -235,11 +235,11 @@ interface WorkflowBuildErrorOptions extends ErrorOptions {
  * discovery, bundler integration) fails in a way the user can act on.
  *
  * This is distinct from `WorkflowRuntimeError` (which is raised at runtime
- * by the workflow engine) — `WorkflowBuildError` fires during `pnpm build`,
+ * by the workflow engine): `WorkflowBuildError` fires during `pnpm build`,
  * `next build`, or equivalent, before any workflow has started executing.
  *
  * Prefer attaching a short, actionable `hint` (e.g. `run \`pnpm install workflow\``)
- * as plain text — the rendering layer is responsible for any styling or
+ * as plain text; the rendering layer is responsible for any styling or
  * "hint:" label. Keeping `hint` plain keeps it useful in non-TTY contexts
  * (CI logs, structured error serialization) where ANSI escapes are noise.
  */
@@ -266,13 +266,13 @@ interface SerializationErrorOptions extends ErrorOptions {
  * returning from a step.
  *
  * Internal invariants (corrupted buffers, unknown format bytes) should use
- * `WorkflowRuntimeError` instead — this class is scoped to things the user
+ * `WorkflowRuntimeError` instead; this class is scoped to things the user
  * can fix in their own code.
  */
 export declare class SerializationError extends WorkflowError {
     readonly hint?: string;
     /**
-     * Serialization errors are deterministic — if a step returns a non-POJO,
+     * Serialization errors are deterministic: if a step returns a non-POJO,
      * replaying the step will always produce the same non-serializable value.
      * Retrying is guaranteed to fail, so these errors are surfaced as fatal
      * and skip the step-retry loop. `FatalError.is()` recognizes any error
@@ -286,7 +286,7 @@ export declare class SerializationError extends WorkflowError {
 /**
  * Thrown when a step function is not registered in the current deployment.
  *
- * This is an infrastructure error — not a user code error. It typically means
+ * This is an infrastructure error, not a user code error. It typically means
  * something went wrong with the bundling/build tooling that caused the step
  * to not get built correctly.
  *
@@ -301,7 +301,7 @@ export declare class StepNotRegisteredError extends WorkflowRuntimeError {
 /**
  * Thrown when a workflow function is not registered in the current deployment.
  *
- * This is an infrastructure error — not a user code error. It typically means:
+ * This is an infrastructure error, not a user code error. It typically means:
  * - A run was started against a deployment that does not have the workflow
  *   (e.g., the workflow was renamed or moved and a new run targeted the latest deployment)
  * - Something went wrong with the bundling/build tooling that caused the workflow
@@ -343,7 +343,7 @@ export declare class WorkflowDeploymentMismatchError extends WorkflowRuntimeErro
  * This error occurs when you call methods on a run object (e.g. `run.status`,
  * `run.cancel()`, `run.returnValue`) but the underlying run ID does not match
  * any known workflow run. Note that `getRun(id)` itself is synchronous and will
- * not throw — this error is raised when subsequent operations discover the run
+ * not throw; this error is raised when subsequent operations discover the run
  * is missing.
  *
  * Use the static `WorkflowRunNotFoundError.is()` method for type-safe checking
@@ -370,7 +370,7 @@ export declare class WorkflowRunNotFoundError extends WorkflowError {
 /**
  * Thrown when a hook token is already in use by another active workflow run.
  *
- * This is a user error — it means the same custom token was passed to
+ * This is a user error: it means the same custom token was passed to
  * `createHook` in two or more concurrent runs. Use a unique token per run
  * (or omit the token to let the runtime generate one automatically).
  */
@@ -403,7 +403,7 @@ export declare class HookConflictError extends WorkflowError {
  *   await resumeHook(token, payload);
  * } catch (error) {
  *   if (HookNotFoundError.is(error)) {
- *     // Hook doesn't exist — start a new workflow run instead
+ *     // Hook doesn't exist, so start a new workflow run instead
  *     await startWorkflow("myWorkflow", payload);
  *   }
  * }
@@ -427,7 +427,7 @@ export declare class EntityConflictError extends WorkflowWorldError {
     static is(value: unknown): value is EntityConflictError;
 }
 /**
- * Thrown when a run is no longer available — either because it has been
+ * Thrown when a run is no longer available, either because it has been
  * cleaned up, expired, or already reached a terminal state (completed/failed).
  *
  * The workflow runtime handles this error automatically. Users interacting
@@ -484,7 +484,7 @@ export declare class ThrottleError extends WorkflowWorldError {
 }
 /**
  * Thrown when the backend rejects an event creation because the client's
- * event-log snapshot is stale — the log the client replayed from is missing
+ * event-log snapshot is stale: the log the client replayed from is missing
  * an event the backend has already recorded (HTTP 412).
  *
  * The workflow runtime handles this automatically: it restarts the replay from
@@ -500,7 +500,7 @@ export declare class ThrottleError extends WorkflowWorldError {
  *   for the whole discrepancy the rejection reported or be omitted entirely; a
  *   client that receives nothing does the authoritative full reload, which is
  *   always correct. Typed `unknown` because this package cannot depend
- *   on the event type — consumers narrow it themselves and must treat a
+ *   on the event type; consumers narrow it themselves and must treat a
  *   missing or malformed value as "no detail" (a full reload is always
  *   correct).
  */
@@ -580,9 +580,9 @@ export declare class RunNotSupportedError extends WorkflowError {
  * Any error can opt into the non-retry behavior by setting a `fatal: true`
  * own property. This is how structured error classes that aren't direct
  * `FatalError` subclasses (e.g. context-violation errors) signal to the
- * step executor that retrying will never help — the user's code is calling
- * a workflow-only API from the wrong context, or similar — and burning
- * retry attempts just produces a wall of duplicated log output.
+ * step executor that retrying will never help (the user's code is calling
+ * a workflow-only API from the wrong context, or similar) and burning
+ * retry attempts produces a wall of duplicated log output.
  */
 export declare class FatalError extends Error {
     fatal: boolean;

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

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

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

@@ -47,6 +47,7 @@ export declare const AnalyticsEventSchema: z.ZodObject<{
     runId: z.ZodString;
     eventId: z.ZodString;
     eventType: z.ZodEnum<{
+        noop: "noop";
         run_created: "run_created";
         run_started: "run_started";
         run_completed: "run_completed";
@@ -135,8 +136,8 @@ export interface AnalyticsListRunsParams {
     /**
      * Bound the listing to runs active between `startTime` and `endTime`
      * (ISO 8601 timestamps). Both must be provided together. A bounded window
-     * lets the backend prune its scan — the ClickHouse-backed Vercel
-     * implementation is significantly faster with one. Requesting a window
+     * lets the backend prune its scan, so the ClickHouse-backed Vercel
+     * implementation is faster with one. Requesting a window
      * older than the plan's observability lookback fails with
      * `observability-upgrade-required`.
      */

package/dist/src/compiled/@workflow/world/attributes-validation.d.ts

@@ -0,0 +1,28 @@
+/** A single run-attribute change. `null` removes the key. */
+export interface AttributeChange {
+    key: string;
+    value: string | null;
+}
+export declare const RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
+export declare const ROOT_RUN_ID_ATTRIBUTE = "$rootRunId";
+export declare const PARENT_RUN_ID_ATTRIBUTE = "$parentRunId";
+export declare const ATTRIBUTE_KEY_MAX_LENGTH = 256;
+export declare const ATTRIBUTE_VALUE_MAX_BYTES = 256;
+export declare const ATTRIBUTE_MAX_PER_RUN = 64;
+/** A validation failure that callers can translate at their API boundary. */
+export declare class AttributeValidationError extends Error {
+    constructor(message: string);
+}
+/** Validates constraints that apply across a batch of individually valid changes. */
+export declare function validateAttributeBatchConstraints(changes: AttributeChange[], context?: {
+    /** Existing keys make the post-merge count exact. */
+    existingKeys?: Iterable<string>;
+}): void;
+export declare function validateAttributeChanges(changes: AttributeChange[], context?: {
+    /** Existing keys make the post-merge count exact. */
+    existingKeys?: Iterable<string>;
+    /** Reserved `$` keys are only available to framework code. */
+    allowReservedAttributes?: boolean;
+}): void;
+export declare function applyAttributeChanges(existing: Record<string, string> | undefined, changes: AttributeChange[]): Record<string, string>;
+//# sourceMappingURL=attributes-validation.d.ts.map

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

@@ -1,117 +1,18 @@
-import { z } from '#compiled/zod/index.js';
-/**
- * Reserved key prefix for system-managed attributes. User code may not set
- * keys starting with `$` — those are blocked at validation time so the
- * namespace remains available for future system use.
- */
-export declare const RESERVED_ATTRIBUTE_KEY_PREFIX = "$";
-/**
- * Reserved attribute keys recording cross-run lineage. `start()` sets these on
- * a run created from inside another run: `$rootRunId` is the root of the chain,
- * `$parentRunId` the direct parent edge.
- */
-export declare const ROOT_RUN_ID_ATTRIBUTE = "$rootRunId";
-export declare const PARENT_RUN_ID_ATTRIBUTE = "$parentRunId";
-/** Max length of an attribute key, in characters. */
-export declare const ATTRIBUTE_KEY_MAX_LENGTH = 256;
-/** Max length of an attribute value, in bytes (UTF-8). */
-export declare const ATTRIBUTE_VALUE_MAX_BYTES = 256;
-/** Max number of attributes on a single run (post-merge). */
-export declare const ATTRIBUTE_MAX_PER_RUN = 64;
-/**
- * A single change in an `experimentalSetAttributes` call. `value: null`
- * means "remove this key from the run's attributes".
- *
- * The shape is deliberately the same as the future `attr_set` event's
- * `eventData.changes` entries so the SDK and wire format do not change
- * when the full attributes feature lands.
- */
+import * as z from '#compiled/zod/index.js';
+export * from './attributes-validation.js';
+export declare const AttributeKeySchema: z.ZodString;
+export declare const AttributeValueSchema: z.ZodNullable<z.ZodString>;
+/** Runtime schema for a single run-attribute change. */
 export declare const AttributeChangeSchema: z.ZodObject<{
     key: z.ZodString;
-    value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    value: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>;
-export type AttributeChange = z.infer<typeof AttributeChangeSchema>;
 export declare const AttributeChangesSchema: z.ZodArray<z.ZodObject<{
     key: z.ZodString;
-    value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    value: z.ZodNullable<z.ZodString>;
 }, z.core.$strip>>;
-/**
- * Result returned by `runs.experimentalSetAttributes` — the post-merge
- * snapshot of all attributes on the run. Provided so callers (notably
- * `setAttributes` and observability emitters) do not need a follow-up read.
- */
+/** The post-merge attribute snapshot returned by a World. */
 export interface ExperimentalSetAttributesResult {
     attributes: Record<string, string>;
 }
-export interface AttributeValidationContext {
-    /**
-     * Existing attribute keys on the run, used to enforce the per-run
-     * cap accurately against the post-merge total — an incoming change
-     * that updates an already-present key contributes zero net adds.
-     *
-     * If omitted, the cap check assumes every non-null change is a fresh
-     * add, which is conservative but still safe (the only false-positive
-     * shape rejects updates to existing keys at the cap boundary; the
-     * authoritative server-side check uses the real post-merge size).
-     */
-    existingKeys?: Iterable<string>;
-    /**
-     * Permit keys that start with the reserved `$` prefix. Default `false`.
-     *
-     * The `$` namespace is reserved for framework / library code built on
-     * top of the workflow SDK (telemetry, agent metadata, etc.). User code
-     * MUST NOT set it; if a user tries, validation rejects the call so
-     * accidental conflicts with tooling-owned keys can't slip through.
-     *
-     * Set this to `true` only from framework-level code that is aware of
-     * the namespace conventions in use. Misuse can collide with tooling
-     * keys and break observability surfaces.
-     */
-    allowReservedAttributes?: boolean;
-}
-export interface AttributeKeyValidationOptions {
-    /**
-     * Permit keys that start with the reserved `$` prefix. See the
-     * `allowReservedAttributes` note on `AttributeValidationContext`.
-     */
-    allowReservedAttributes?: boolean;
-}
-/**
- * Thrown when an attribute key or value violates one of the validation
- * rules. Use a plain `Error` here so the world layer can decide whether
- * to wrap as `FatalError` (SDK) or return a 400 (server endpoint).
- */
-export declare class AttributeValidationError extends Error {
-    constructor(message: string);
-}
-/**
- * Validate a single attribute key. Returns an `AttributeValidationError`
- * on violation, or `null` if the key is valid. Returning instead of
- * throwing lets callers aggregate or wrap the failure as needed.
- *
- * The reserved `$`-prefix rule is enforced by default; framework code
- * may pass `allowReservedAttributes: true` to opt out.
- */
-export declare function validateAttributeKey(key: string, options?: AttributeKeyValidationOptions): AttributeValidationError | null;
-/**
- * Validate a single attribute value. `null` represents an unset and is
- * always valid. Returns an `AttributeValidationError` on violation or
- * `null` if the value is valid.
- */
-export declare function validateAttributeValue(value: string | null): AttributeValidationError | null;
-/**
- * Validate a batch of attribute changes. Throws `AttributeValidationError`
- * on the first violation found. Pass `existingKeys` (in `context`) so
- * the per-run cap check can use the real post-merge total — without it
- * the check is conservative and may reject an update to an
- * already-present key when the run is at the cap.
- */
-export declare function validateAttributeChanges(changes: AttributeChange[], context?: AttributeValidationContext): void;
-/**
- * Apply a batch of validated changes to an existing attribute map. Returns
- * a new map; does not mutate the input. The world layer uses this to
- * compute the post-merge snapshot when the underlying store cannot do the
- * merge in a single atomic operation.
- */
-export declare function applyAttributeChanges(existing: Record<string, string> | undefined, changes: AttributeChange[]): Record<string, string>;
 //# sourceMappingURL=attributes.d.ts.map

package/dist/src/compiled/@workflow/world/env-config.d.ts

@@ -3,14 +3,14 @@
  * variables.
  *
  * Several SDK constants (timeouts, retry counts, stream buffering, …) are
- * useful to tune per-deployment — most notably to dial them down on a
+ * useful to tune per-deployment, most notably to dial them down on a
  * dedicated e2e deployment so the test suite exercises edge paths (reconnects,
  * batch splitting, retries) that otherwise only trigger after long durations
  * or large payloads.
  *
  * `envNumber` reads `process.env[name]` lazily (so tests and deployments can
  * override per invocation), clamps to an optional `[min, max]` range, and
- * never throws — an env override is an escape hatch, not a hard requirement,
+ * never throws: an env override is an escape hatch, not a hard requirement,
  * so an invalid value falls back to the constant's compiled-in default. A
  * misconfigured value warns once per process so the mistake is observable
  * without spamming logs.
@@ -35,13 +35,13 @@ export declare function envNumber(name: string, fallback: number, options?: EnvN
  * Matches the convention the runtime flags already use (`WORKFLOW_TURBO`,
  * `WORKFLOW_SLOT_IDENTITY`, …): unset or empty takes `fallback`, and the only
  * values that force a side are `0` / `false` and `1` / `true`
- * (case-insensitive). Anything else falls back rather than throwing — a flag is
- * an escape hatch, not a hard requirement — and warns once per process.
+ * (case-insensitive). Anything else falls back rather than throwing (a flag is
+ * an escape hatch, not a hard requirement) and warns once per process.
  */
 export declare function envFlag(name: string, fallback: boolean, env?: Record<string, string | undefined>): boolean;
 export declare function getMaxEventsPerRun(): number;
 /**
- * Reset the warn-once cache. Test-only — exported so unit tests can exercise
+ * Reset the warn-once cache. Test-only, exported so unit tests can exercise
  * the warning path repeatedly without sharing state across cases.
  *
  * @internal

package/dist/src/compiled/@workflow/world/event-metadata.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Whether an event is a sealed-log filler occupying an abandoned slot.
+ *
+ * The single home for this test, deliberately: a noop is invisible to the run
+ * but it is a real row of the log, so every pass over a log has to decide
+ * whether it is walking positions (count it) or reconstructing what happened
+ * (skip it). The replay engines and observability trace builder must agree
+ * that a noop's `createdAt` — the sealer's wall clock, which can postdate every
+ * real event around it — never becomes a time the run observed.
+ *
+ * Keeping the classifier in this schema-free module lets replay code make that
+ * decision without pulling the event validation graph into workflow bundles.
+ */
+export declare function isSealedNoopEvent(event: {
+    eventType: string;
+}): boolean;
+/**
+ * Groups event types into the classes a replay tracks per entity: the entity
+ * named by the event's `correlationId`, or the run itself for run events,
+ * which carry none.
+ *
+ * Types that share a class are the mutually exclusive outcomes of one
+ * decision, so the log records the class once and the first event of it is the
+ * one that counts: a step either completes or fails.
+ *
+ * Classes are independent of each other. A step whose result is in the log has
+ * still recorded exactly one `step_created`, and can still record another
+ * `step_started` if an attempt is running somewhere. What a class bounds is
+ * which events can be *ignored*: a replay may pass over an event whose class
+ * it already recorded for that entity and which no consumer wants (see
+ * `EventsConsumer`), and only then.
+ *
+ * `attr_set` is here for the correlation id a workflow-body attribute write
+ * draws, which resolves exactly once: the dispatcher's consumer takes the
+ * matching event and deregisters, so a second event under that id has no
+ * callback left and never will. Without a class it would instead be parked for
+ * a consumer that cannot come, and parking is only ever settled by the
+ * workflow function returning, at which point it is reported as a stranded
+ * event and kills a run that did all its work correctly. An attribute write
+ * from a *step* body carries no correlation id and is claimed by the
+ * structural lifecycle consumer in `workflow.ts` on the way past, so it is
+ * consumed rather than skipped and several of them never collapse into one
+ * class.
+ *
+ * Note the omissions, all of them types a mapping would be dead weight for.
+ * `hook_received` and `hook_conflict` are deliveries whose consumer subscribes
+ * lazily, and `run_created` precedes every replay. The terminal run types are
+ * absent for a different reason: recording a class requires a consumer to take
+ * an event of it, and no consumer takes `run_completed` / `run_failed` /
+ * `run_cancelled`: the runtime exits before replaying the body once the log
+ * holds one, so they never reach a consumer at all. An entry for them could
+ * never match.
+ */
+declare const ENTITY_EVENT_CLASS_BY_TYPE: {
+    readonly attr_set: "attr_set";
+    readonly step_created: "step_created";
+    readonly step_started: "step_started";
+    readonly step_retrying: "step_retrying";
+    readonly step_completed: "step_terminal";
+    readonly step_failed: "step_terminal";
+    readonly wait_created: "wait_created";
+    readonly wait_completed: "wait_completed";
+    readonly hook_created: "hook_created";
+    readonly hook_disposed: "hook_disposed";
+    readonly run_started: "run_started";
+};
+export type EntityEventClass = (typeof ENTITY_EVENT_CLASS_BY_TYPE)[keyof typeof ENTITY_EVENT_CLASS_BY_TYPE];
+export declare function entityEventClass(eventType: string): EntityEventClass | undefined;
+/** Entity key for a class the log records once per run rather than per entity. */
+export declare const RUN_ENTITY_KEY = "";
+/** The class an event belongs to, and the entity that class is tracked under. */
+export interface EntityEventClassification {
+    eventClass: EntityEventClass;
+    /** The event's `correlationId`, or {@link RUN_ENTITY_KEY} for run classes. */
+    entity: string;
+}
+/**
+ * Classes whose event closes its entity: the consumer deregisters on it, so
+ * nothing claims another event under that correlation id afterwards.
+ *
+ * This is what makes a later event of an already-recorded class a straggler
+ * rather than another attempt. A class not listed here leaves its entity open,
+ * and a repeat is claimed by the live consumer: each retry of a step writes
+ * another `step_started`, and a step that has not finished absorbs a second
+ * `step_created`.
+ *
+ * `attr_set` is one of these. The dispatcher's consumer in
+ * `attribute-dispatcher.ts` returns `Finished` on the event it matches, so an
+ * attribute id closes on the first event under it.
+ */
+export declare const TERMINAL_EVENT_CLASSES: ReadonlySet<EntityEventClass>;
+/**
+ * The class and entity an event is tracked under, or `undefined` when it is
+ * tracked under none and can therefore never be read as a repeat of one.
+ *
+ * The single home for the rule, because two codebases apply it and a run is
+ * misread if they disagree: the runtime skips an event by it while replaying
+ * (`EventsConsumer`), and the observability UI greys one out by it after the
+ * fact (`@workflow/web-shared`). A shared fixture corpus pins them together
+ * (see `test-support/duplicate-event-fixtures.ts`).
+ *
+ * An entity class needs an entity. Every classed type carries a correlation id
+ * except two: `run_started`, whose class is the run's own and keys off
+ * {@link RUN_ENTITY_KEY}, and an `attr_set` written from a *step* body, which
+ * has no workflow-body call behind it and so names no entity. Without this the
+ * step-written ones would all collapse into one class for the run and the
+ * second of them would read as a repeat of the first, which would hide
+ * attribute writes that really happened — a run can carry dozens.
+ */
+export declare function classifyEntityEvent(event: {
+    eventType: string;
+    correlationId?: string | null;
+}): EntityEventClassification | undefined;
+/** Opaque payload fields removed when events load without referenced data. */
+declare const EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE: {
+    readonly run_created: readonly ["input"];
+    readonly run_started: readonly ["input"];
+    readonly run_completed: readonly ["output"];
+    readonly run_failed: readonly ["error"];
+    readonly step_created: readonly ["input"];
+    readonly step_started: readonly ["input"];
+    readonly step_completed: readonly ["result"];
+    readonly step_failed: readonly ["error"];
+    readonly step_retrying: readonly ["error"];
+    readonly hook_created: readonly ["metadata"];
+    readonly hook_received: readonly ["payload"];
+};
+export type EventDataPayloadField = (typeof EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE)[keyof typeof EVENT_DATA_REF_FIELDS_BY_EVENT_TYPE][number];
+export declare function getEventDataRefFields(eventType: string): readonly EventDataPayloadField[];
+export declare function getEventDataPayloadField(eventType: string): EventDataPayloadField | undefined;
+export {};
+//# sourceMappingURL=event-metadata.d.ts.map