eve 0.48.0 → 0.49.0

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

@@ -4,7 +4,9 @@ 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 * from './event-metadata.js';
 export declare const EventTypeSchema: z.ZodEnum<{
+    noop: "noop";
     run_created: "run_created";
     run_started: "run_started";
     run_completed: "run_completed";
@@ -59,49 +61,6 @@ declare const TerminalStepEventTypeSchema: z.ZodEnum<{
 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;
-/**
- * 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.
- *
- * 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, `attr_set` is written on every attribute write, 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 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];
-/**
- * The per-entity class `eventType` belongs to, or `undefined` when it belongs
- * to none. See {@link ENTITY_EVENT_CLASS_BY_TYPE}.
- */
-export declare function entityEventClass(eventType: string): EntityEventClass | undefined;
 declare const HookLifecycleEventTypeSchema: z.ZodEnum<{
     hook_created: "hook_created";
     hook_received: "hook_received";
@@ -132,33 +91,6 @@ declare const ChildEntityCreationEventTypeSchema: z.ZodEnum<{
 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
@@ -167,6 +99,7 @@ export declare function getEventDataPayloadField(eventType: string): EventDataPa
 export declare function stripEventDataRefs(event: Event, resolveData: ResolveData): Event;
 export declare const BaseEventSchema: z.ZodObject<{
     eventType: z.ZodEnum<{
+        noop: "noop";
         run_created: "run_created";
         run_started: "run_started";
         run_completed: "run_completed";
@@ -303,7 +236,7 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     eventData: z.ZodObject<{
         changes: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+            value: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>>;
         writer: z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<"workflow">;
@@ -470,7 +403,7 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventData: z.ZodObject<{
         changes: z.ZodArray<z.ZodObject<{
             key: z.ZodString;
-            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+            value: z.ZodNullable<z.ZodString>;
         }, z.core.$strip>>;
         writer: z.ZodDiscriminatedUnion<[z.ZodObject<{
             type: z.ZodLiteral<"workflow">;
@@ -589,6 +522,13 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     eventData: z.ZodOptional<z.ZodObject<{
         resumeAt: z.ZodOptional<z.ZodCoercedDate<unknown>>;
     }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    correlationId: z.ZodOptional<z.ZodString>;
+    specVersion: z.ZodOptional<z.ZodNumber>;
+    eventType: z.ZodLiteral<"noop">;
+    eventData: z.ZodOptional<z.ZodObject<{
+        sealed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
 }, z.core.$strip>], "eventType">, z.ZodObject<{
     runId: z.ZodString;
     eventId: z.ZodString;
@@ -652,7 +592,7 @@ export interface CreateEventParams {
     resumePayloadDigest?: string;
     /**
      * Marks a `step_created` create as the queue consumer's re-ensure of a
-     * resilient step dispatch (a step message carrying `stepInput` — see
+     * resilient step dispatch (a step message carrying `stepInput`, see
      * `WorkflowInvokePayload.stepInput`): the producer's direct write was
      * parallelized with the queue publish and may have failed. Only meaningful
      * for `step_created`.
@@ -664,9 +604,9 @@ export interface CreateEventParams {
      * this flag to narrow it: refuse the re-ensure (world-vercel surfaces the
      * backend's 410 as `RunExpiredError`, which the consumer treats as "nothing
      * left to execute" and acks the message) when it has recorded a refusal for
-     * this correlation id and no step entity exists. Best-effort by nature — a
+     * this correlation id and no step entity exists. Best-effort by nature (a
      * marker written at refusal time cannot be ordered before the redelivery it
-     * is meant to stop — so it hardens, and does not close, the window. Worlds
+     * is meant to stop), so it hardens, and does not close, the window. Worlds
      * may ignore this flag entirely.
      */
     viaStepDispatch?: boolean;
@@ -681,16 +621,16 @@ export interface CreateEventParams {
     computeInstanceId?: 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. Sent by
+     * this one: equivalently, the slot it expects to land on minus one. Sent by
      * every replay-context create; omitted by callers with no loaded log to be
      * stale against.
      *
      * A World's slots are dense and 1-based (see `Storage.events`), so a count
      * and a position are the same number. An id that is not a position does not
-     * produce a count here — it throws, since the runtime cannot state a
+     * produce a count here: it throws, since the runtime cannot state a
      * snapshot for a log it cannot place. 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
+     * 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
@@ -728,7 +668,7 @@ export interface CreateEventParams {
     /**
      * Inline-delta optimization (opt-in). When set, the World MAY return,
      * on the resulting {@link EventResult}, the first page of events written
-     * strictly after this cursor (via `events`/`cursor`/`hasMore`) — the
+     * 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. Outside turbo mode the
      * runtime sets this on every write it makes from the orchestrator loop
@@ -736,7 +676,7 @@ export interface CreateEventParams {
      * 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
+     * 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.
      *
@@ -747,7 +687,7 @@ export interface CreateEventParams {
      * `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
+     * 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
      * delta is computed atomically against the same log the fetch would read.
@@ -759,7 +699,7 @@ export interface CreateEventParams {
      * (`events`/`cursor`/`hasMore`) so the runtime can skip its initial
      * `events.list`. The turbo first invocation backgrounds `run_started`
      * purely as a write barrier and never reads that preload, so it sets this
-     * to tell the World to skip the wasted list+resolve — trimming the
+     * to tell the World to skip the wasted list+resolve, trimming the
      * `run_started` round-trip that the chained first `step_started` waits on.
      * A World that ignores it (or doesn't preload) remains fully correct: the
      * runtime falls back to `events.list` whenever it actually needs the log.
@@ -771,7 +711,7 @@ export interface CreateEventParams {
      */
     skipPreload?: true;
     /**
-     * Replay-log preload opt-in (advisory) — the `hook_received` dual of
+     * Replay-log preload opt-in (advisory): the `hook_received` dual of
      * {@link skipPreload}. Set only by the queue consumer's idempotent
      * `hook_received` re-ensure on a lazy hook resume (alongside
      * {@link resumeId} + {@link resumePayloadDigest}). A World MAY return the
@@ -781,15 +721,15 @@ export interface CreateEventParams {
      * `run_started` write and the initial `events.list`.
      *
      * The runtime trusts a returned preload as replay input ONLY when all of
-     * the following hold — a World that cannot guarantee them should return
-     * its normal {@link EventResult} instead:
+     * the following hold (a World that cannot guarantee them should return
+     * its normal {@link EventResult} instead):
      *
      * - `events` is the COMPLETE log with `hasMore: false` (the runtime has no
      *   cursor-continuation machinery on this path; a bounded page is
      *   rejected).
      * - `cursor` is a valid non-null resume point matching `events.list`
      *   semantics (present even on the final page).
-     * - `run` (with `run.startedAt`) and `maxEvents` are present — this
+     * - `run` (with `run.startedAt`) and `maxEvents` are present: this
      *   response plays `run_started`'s role, including the event-ceiling
      *   handshake.
      * - The log contains `run_created`, `run_started`, and the canonical
@@ -800,12 +740,19 @@ export interface CreateEventParams {
      *   omitted from the replay input.
      *
      * Anything less and the runtime observes that no usable replay preload
-     * came back and falls back to the existing `run_started` setup — a World
+     * came back and falls back to the existing `run_started` setup. A World
      * that ignores the param entirely remains fully correct. Only meaningful
      * for `hook_received`; ignored for other event types. Producer-side
      * `resumeHook()` must not set it.
      */
     preloadEvents?: true;
+    /**
+     * Synchronously observes each validated event in a streamed replay-log
+     * response. A retried request may observe the same event again; observers
+     * must therefore be idempotent. Throwing aborts the operation and the World
+     * must surface the original error without retrying or reclassifying it.
+     */
+    replayEventObserver?: (event: Event) => void;
 }
 /**
  * Result of creating an event. Includes the created event and optionally
@@ -829,7 +776,7 @@ export type EventResult<T extends EventType = EventType> = {
      * 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
+     * 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
@@ -856,7 +803,7 @@ export type EventResult<T extends EventType = EventType> = {
      * - On any response 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
+     *   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.
      */
@@ -878,7 +825,7 @@ export type EventResult<T extends EventType = EventType> = {
 } : unknown);
 /**
  * One event of a batch write ({@link Storage.events.createBatch}), in request
- * order — which is the order the events land in the run's log.
+ * order, which is the order the events land in the run's log.
  */
 export interface BatchEventRequest {
     /** The event, same discriminated union the single `create` takes. */
@@ -886,7 +833,7 @@ export interface BatchEventRequest {
     /**
      * Client event time for this event. Under slot identity this is the source
      * of the durable event's `createdAt` (a slot id carries no time), so the
-     * timestamp a replay observes is the one the writer chose — set it to the
+     * timestamp a replay observes is the one the writer chose: set it to the
      * instant the event logically occurred.
      */
     occurredAt?: Date;
@@ -922,7 +869,7 @@ export interface CreateEventBatchParams {
  * - rejection → the status code and error code the single create would have
  *   failed with, so callers reuse their single-path conflict handling per
  *   event. A `409`/`conflict` means the entity was not in the prior state
- *   the event requires — most commonly because an earlier delivery already
+ *   the event requires, most commonly because an earlier delivery already
  *   applied the same event, but possibly because the entity reached a
  *   DIFFERENT state (e.g. `step_completed` conflicting because the step
  *   failed). A 409 alone does not prove the equivalent effect was applied;
@@ -934,10 +881,10 @@ export interface CreateEventBatchParams {
  * can return a mix of 200s and 409s from one call.
  *
  * Retry semantics: a transport retry of a committed batch converges to
- * per-event 409s ONLY for entity-conditioned events — creates and terminal
+ * per-event 409s ONLY for entity-conditioned events: creates and terminal
  * transitions. A standalone bare `step_started` or a `step_retrying`
  * re-patches its step on every attempt and does NOT converge, and
- * `hook_received` appends a new row per attempt — `world-vercel` rejects
+ * `hook_received` appends a new row per attempt, so `world-vercel` rejects
  * `hook_received` in a batch outright and only auto-retries batches whose
  * every event is retry-convergent.
  *
@@ -988,12 +935,11 @@ export interface ListEventsByCorrelationIdParams {
      * run, not globally: a slot-numbered run counts its own steps and waits, so
      * `step_…001` names the first step of *every* such run. Naming the run is
      * what makes the answer that run's events, and it is what makes the
-     * pagination cursor unambiguous — `(runId, eventId)` is a key where an
+     * pagination cursor unambiguous: `(runId, eventId)` is a key where an
      * event id alone is not.
      */
     runId: string;
     pagination?: PaginationOptions;
     resolveData?: ResolveData;
 }
-export {};
 //# sourceMappingURL=events.d.ts.map

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

@@ -2,14 +2,14 @@ import { z } from '#compiled/zod/index.js';
 import type { SerializedData } from './serialization.js';
 import type { PaginationOptions, ResolveData } from './shared.js';
 /**
- * Minimal, immutable slice of a hook's owning run needed to resume it —
+ * Minimal, immutable slice of a hook's owning run needed to resume it:
  * enough for encryption-key resolution, serialization/compression capability
  * selection, queue routing, and trace linking, without fetching the full run.
  *
  * Persisted on new hook records (workflow-server) and also returned inline by
  * `getByToken`, so a resume can skip the separate `runs.get`. Deliberately
  * excludes the run's mutable state (e.g. status), inputs/outputs, attributes,
- * and any secret — only fields that are fixed at hook-creation time.
+ * and any secret: only fields that are fixed at hook-creation time.
  */
 export declare const HookResumeContextSchema: z.ZodObject<{
     deploymentId: z.ZodString;
@@ -26,17 +26,18 @@ export type HookResumeContext = z.infer<typeof HookResumeContextSchema>;
  * deployment stamps this into its execution context (and the server mirrors it
  * onto `HookResumeContext.hookResumeInputVersion`) to attest that its
  * `@workflow/core` re-ensures the `hook_received` event from a queue message's
- * `hookInput`. `resumeHook()`'s parallel fast path requires the target run's
- * marker to be at least this value. Bump only on a breaking change to the
- * `hookInput` re-ensure contract.
+ * `hookInput`. Current producers write the event durably BEFORE publishing the
+ * wake and do not read this marker; it exists for older producers whose lazy
+ * path requires the target run's marker to be at least this value. Bump only
+ * on a breaking change to the `hookInput` re-ensure contract.
  */
 export declare const HOOK_RESUME_INPUT_VERSION = 1;
 /**
  * Current version of the backend lazy-hook-resume dedup contract: the live
- * backend enforces a `(runId, resumeId)` constraint so the direct write and the
- * queue consumer's re-ensure converge on exactly one `hook_received`.
- * `resumeHook()`'s parallel fast path requires the backend to attest at least
- * this version. Bump only on a breaking change to the constraint semantics.
+ * backend enforces a `(runId, resumeId)` constraint so repeated deliveries of
+ * one resume's queue message converge on exactly one `hook_received`.
+ * `resumeHook()`'s lazy path requires the backend to attest at least this
+ * version. Bump only on a breaking change to the constraint semantics.
  */
 export declare const HOOK_RESUME_DEDUP_VERSION = 1;
 /**
@@ -45,8 +46,8 @@ export declare const HOOK_RESUME_DEDUP_VERSION = 1;
  *
  * Response-only and transient: NEVER persisted on the hook entity and NEVER
  * part of {@link HookResumeContextSchema}. Recomputing it per response is what
- * makes a server rollback or kill switch take effect immediately — a rolled-back
- * or kill-switched server simply stops emitting it, dropping new resumes to the
+ * makes a server rollback or kill switch take effect immediately: a rolled-back
+ * or kill-switched server stops emitting it, dropping new resumes to the
  * sequential path with no stranded hooks. (Contrast with the per-run, persisted
  * `hookResumeInputVersion`, which attests the *consumer* and is fixed at run
  * creation.)

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

@@ -1,10 +1,10 @@
 export type * from './analytics.js';
 export { ANALYTICS_EVENTS_GET_MANY_LIMIT, 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 { ATTRIBUTE_KEY_MAX_LENGTH, ATTRIBUTE_MAX_PER_RUN, ATTRIBUTE_VALUE_MAX_BYTES, AttributeChangeSchema, AttributeChangesSchema, AttributeKeySchema, AttributeValidationError, AttributeValueSchema, applyAttributeChanges, PARENT_RUN_ID_ATTRIBUTE, RESERVED_ATTRIBUTE_KEY_PREFIX, ROOT_RUN_ID_ATTRIBUTE, validateAttributeChanges, } from './attributes.js';
 export { _resetEnvWarnCacheForTests, type EnvNumberOptions, envFlag, 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, entityEventClass, 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 { BaseEventSchema, CHILD_ENTITY_CREATION_EVENT_TYPES, CreateEventSchema, classifyEntityEvent, EventSchema, EventTypeSchema, entityEventClass, getEventDataPayloadField, getEventDataRefFields, HOOK_EVENTS_REQUIRING_EXISTENCE, HOOK_LIFECYCLE_EVENT_TYPES, HookCreatedEventSchema, isChildEntityCreationEvent, isChildEntityCreationEventType, isHookEventRequiringExistence, isHookLifecycleEventType, isRunEventType, isSealedNoopEvent, isStepEventType, isTerminalRunEventType, isTerminalStepEventType, isWaitEventType, RUN_ENTITY_KEY, RUN_EVENT_TYPES, STEP_EVENT_TYPES, stripEventDataRefs, TERMINAL_EVENT_CLASSES, TERMINAL_RUN_EVENT_TYPES, TERMINAL_STEP_EVENT_TYPES, TerminalRunEventTypeSchema, WAIT_EVENT_TYPES, } from './events.js';
 export type * from './hooks.js';
 export { HOOK_RESUME_DEDUP_VERSION, HOOK_RESUME_INPUT_VERSION, HookResumeCapabilitiesSchema, HookSchema, } from './hooks.js';
 export type * from './interfaces.js';
@@ -21,7 +21,7 @@ export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoRes
 export { 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, 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 { 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_SEALED_LOG, 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';