eve 0.7.0 → 0.7.2

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

@@ -27,6 +27,17 @@ export declare const SerializationFormat: {
     /** Encrypted payload (inner payload has its own format prefix) */
     readonly ENCRYPTED: FormatPrefix;
 };
+/**
+ * Wire-framing format identifier carried in the serialized
+ * `ReadableStream` ref's `framing` field.
+ *
+ * - absent / `'raw'`: chunks are written to the transport verbatim
+ *   (legacy format — no auto-reconnect support).
+ * - `'framed-v1'`: each chunk is wrapped in a 4-byte big-endian length
+ *   prefix, allowing the reader to identify chunk boundaries and
+ *   transparently reconnect on transient stream errors.
+ */
+export type ByteStreamFraming = 'raw' | 'framed-v1';
 /**
  * Types that need specialized handling when serialized/deserialized.
  * If a type is added here, it MUST also be added to the `Serializable`
@@ -83,6 +94,16 @@ export interface SerializableSpecial {
         name: string;
         type?: 'bytes';
         startIndex?: number;
+        /**
+         * Wire-framing format for byte streams. See {@link ByteStreamFraming}
+         * and `getByteFramingStream` / `getByteUnframingStream`.
+         *
+         * Only meaningful when `type === 'bytes'`. Absent on object streams
+         * (which always use length-prefixed devalue framing) and on legacy
+         * byte streams written by SDKs that predate framing support — those
+         * are interpreted as `'raw'` by the consumer.
+         */
+        framing?: ByteStreamFraming;
     } | {
         bodyInit: any;
     };

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

@@ -13,6 +13,39 @@ export type SerializationFormatType = (typeof SerializationFormat)[keyof typeof
 export declare function getStreamType(stream: ReadableStream): 'bytes' | undefined;
 export declare function getSerializeStream(reducers: Partial<Reducers>, cryptoKey: EncryptionKeyParam): TransformStream<any, Uint8Array>;
 export declare function getDeserializeStream(revivers: Partial<Revivers>, cryptoKey: EncryptionKeyParam): TransformStream<Uint8Array, any>;
+/**
+ * Wraps each chunk of a byte stream in a 4-byte big-endian length
+ * prefix. Used by the producer side of a framed byte-stream pipe.
+ *
+ * Empty chunks (length 0) are dropped — the resulting `[0x00 0x00 0x00 0x00]`
+ * frame would be ambiguous with the legacy "looks framed" detection in
+ * `getDeserializeStream`, and it carries no information.
+ *
+ * Load-bearing invariant: each user chunk becomes exactly one frame, and
+ * each frame is enqueued as exactly one transport chunk (the downstream
+ * writable performs one wire write per chunk, preserving boundaries). The
+ * server therefore stores one frame per chunk index, which is what allows
+ * a future reconnecting reader to resume a framed byte stream at
+ * `startIndex + consumedFrames` — the same arithmetic
+ * `createReconnectingFramedStream` relies on for object streams. Do not
+ * coalesce or split frames here without revisiting that resume logic.
+ */
+export declare function getByteFramingStream(): TransformStream<Uint8Array, Uint8Array>;
+/**
+ * Unwraps length-prefixed byte-stream frames back into the original user
+ * chunks. Used by the consumer side of a framed byte-stream pipe.
+ *
+ * Buffers across read boundaries — the transport may split a single
+ * frame across multiple reads (header in one chunk, payload in another)
+ * or coalesce multiple frames into a single read. The transform emits
+ * whole user chunks regardless of transport chunking.
+ *
+ * Errors the stream if the length header advertises a frame larger than
+ * `MAX_FRAME_SIZE` bytes, since that almost certainly indicates a
+ * misframed wire (e.g. a raw byte stream being fed through this transform
+ * by mistake) and we don't want to allocate an enormous buffer.
+ */
+export declare function getByteUnframingStream(): TransformStream<Uint8Array, Uint8Array>;
 export declare class WorkflowServerReadableStream extends ReadableStream<Uint8Array> {
     #private;
     constructor(runId: string, name: string, startIndex?: number);
@@ -61,17 +94,24 @@ export declare function createReconnectingFramedStream(runId: string, name: stri
 export declare class WorkflowServerWritableStream extends WritableStream<Uint8Array> {
     constructor(runId: string, name: string);
 }
-export type { Reducers, Revivers, SerializableSpecial, } from './serialization/types.js';
-import type { Reducers, Revivers } from './serialization/types.js';
+export type { ByteStreamFraming, Reducers, Revivers, SerializableSpecial, } from './serialization/types.js';
+import type { ByteStreamFraming, Reducers, Revivers } from './serialization/types.js';
 /**
  * Reducers for serialization boundary from the client side, passing arguments
  * to the workflow handler.
  *
  * @param global
  * @param ops
+ * @param runId
+ * @param cryptoKey
+ * @param framedByteStreams - When `true`, byte streams (`type: 'bytes'`)
+ *   are wrapped in length-prefixed frames on the wire so the consumer
+ *   can reconnect on transient errors. Should match the target run's
+ *   capability — see `getRunCapabilities` in `capabilities.ts`. Defaults
+ *   to `false` for backwards compatibility with older runs.
  * @returns
  */
-export declare function getExternalReducers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam): Partial<Reducers>;
+export declare function getExternalReducers(global: Record<string, any> | undefined, ops: Promise<void>[], runId: string, cryptoKey: EncryptionKeyParam, framedByteStreams?: boolean): Partial<Reducers>;
 /**
  * Reducers for serialization boundary from within the workflow execution
  * environment, passing return value to the client side and into step arguments.
@@ -144,6 +184,7 @@ export declare function getCommonRevivers(global?: Record<string, any>): {
         name: string;
         type?: "bytes";
         startIndex?: number;
+        framing?: ByteStreamFraming;
     } | {
         bodyInit: any;
     }) => any) | undefined;
@@ -283,8 +324,20 @@ export declare function maybeDecrypt(data: Uint8Array | unknown, key: CryptoKey
  * Called from the `start()` function to serialize the workflow arguments
  * into a format that can be saved to the database and then hydrated from
  * within the workflow execution environment.
+ *
+ * @param value - The value to serialize
+ * @param runId - The workflow run ID (required for encryption context)
+ * @param key - Encryption key (undefined to skip encryption)
+ * @param ops - Promise array for stream operations
+ * @param global - Global object for serialization context
+ * @param v1Compat - Enable legacy v1 compatibility mode
+ * @param framedByteStreams - Whether the target run can decode wire-framed
+ *   byte streams. Should match the target deployment's capability — see
+ *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
+ *   backwards compatibility with older runs.
+ * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateWorkflowArguments(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<void>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from workflow execution environment to hydrate the workflow
  * arguments from the database at the start of workflow execution.
@@ -311,9 +364,22 @@ export declare function dehydrateStepArguments(value: unknown, _runId: string, k
 export declare function hydrateStepArguments(value: Uint8Array | unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, extraRevivers?: Record<string, (value: any) => any>, deploymentId?: string): Promise<any>;
 /**
  * Called from the step handler when a step has completed.
- * Dehydrates values from within the step execution environment.
+ * Dehydrates values from within the step execution environment
+ * into a format that can be saved to the database.
+ *
+ * @param value - The value to serialize
+ * @param runId - Run ID for encryption context
+ * @param key - Encryption key (undefined to skip encryption)
+ * @param ops - Promise array for stream operations
+ * @param global - Global object for serialization context
+ * @param v1Compat - Enable legacy v1 compatibility mode
+ * @param framedByteStreams - Whether the target run can decode wire-framed
+ *   byte streams. Should match the target deployment's capability — see
+ *   `getRunCapabilities` in `capabilities.ts`. Defaults to `false` for
+ *   backwards compatibility with older runs.
+ * @returns The dehydrated value as binary data (Uint8Array) with format prefix
  */
-export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean): Promise<Uint8Array | unknown>;
+export declare function dehydrateStepReturnValue(value: unknown, runId: string, key: CryptoKey | undefined, ops?: Promise<any>[], global?: Record<string, any>, v1Compat?: boolean, framedByteStreams?: boolean): Promise<Uint8Array | unknown>;
 /**
  * Called from the step handler when a step throws. Dehydrates the thrown
  * value from within the step execution environment into a format that can

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

@@ -1,4 +1,5 @@
 export declare const WORKFLOW_USE_STEP: unique symbol;
+export declare const WORKFLOW_SET_ATTRIBUTES: unique symbol;
 export declare const WORKFLOW_CREATE_HOOK: unique symbol;
 export declare const WORKFLOW_SLEEP: unique symbol;
 export declare const WORKFLOW_CONTEXT: unique symbol;
@@ -6,6 +7,7 @@ export declare const WORKFLOW_GET_STREAM_ID: unique symbol;
 export declare const STABLE_ULID: unique symbol;
 export declare const STREAM_NAME_SYMBOL: unique symbol;
 export declare const STREAM_TYPE_SYMBOL: unique symbol;
+export declare const STREAM_FRAMING_SYMBOL: unique symbol;
 /**
  * Stamped on a real `WritableStream` (the user-visible `serialize.writable`
  * returned from a step-side reviver or step-context `getWritable()`) to

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

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

package/dist/src/compiled/@workflow/core/workflow/attribute-dispatcher.d.ts

@@ -0,0 +1,6 @@
+import type { AttributeChange } from '#compiled/@workflow/world/index.js';
+import { type WorkflowOrchestratorContext } from '../private.js';
+export declare function createSetAttributes(ctx: WorkflowOrchestratorContext): (changes: AttributeChange[], options?: {
+    allowReservedAttributes?: boolean;
+}) => Promise<void>;
+//# sourceMappingURL=attribute-dispatcher.d.ts.map

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

@@ -29,11 +29,10 @@ export interface ExperimentalSetAttributesOptions {
  * breaking rename later.
  *
  * Callable only from a workflow body (`'use workflow'`). The call is
- * dispatched through the workflow runtime as a step, so the mutation
- * is recorded in the event log and survives replay.
+ * dispatched as a native `attr_set` event and materialized on the run.
  *
- * Validation runs in the VM (cheap, deterministic) before the step
- * dispatch — violations throw `FatalError` without queuing a step. An
+ * Validation runs in the VM (cheap, deterministic) before event
+ * dispatch - violations throw `FatalError` without writing an event. An
  * empty record is a no-op. `value: undefined` removes the key from the
  * run's attribute map.
  *

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

@@ -1 +1 @@
-import{c as e,i as t}from"../../_chunks/workflow/dist-6a3viBXZ.js";import{at as n,g as r,it as i,lt as a,m as o,p as s,s as c,st as l}from"../../_chunks/workflow/symbols-BUTtwS7j.js";import{n as u,t as d}from"../../_chunks/workflow/sleep-Cup6vPoA.js";async function f(e,n={}){let i=u(e,n);if(i.length===0)return;let a=n.allowReservedAttributes===!0,o=globalThis[r];if(!o)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await o(`__builtin_set_attributes`)(i,a?{allowReservedAttributes:!0}:{})}function p(e){let t=globalThis[s];return t||n(`createHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow/create-hook`,p),t(e)}function m(e){let{respondWith:t,token:n,...r}=e??{};if(n!==void 0)throw Error("`createWebhook()` does not accept a `token` option. Webhook tokens are always randomly generated. Use `createHook()` with `resumeHook()` for deterministic token patterns.");let i;t!==void 0&&(i={respondWith:t});let o=p({...r,metadata:i,isWebhook:!0}),{url:s}=a();return o.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(o.token)}`,o}function h(){function e(t,n){l(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return p(e)},resume:e}}function g(e={}){let{namespace:t}=e,n=globalThis[o](t);return Object.create(globalThis.WritableStream.prototype,{[c]:{value:n,writable:!1}})}function _(){i(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,_)}function v(){l(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,v)}export{t as FatalError,e as RetryableError,p as createHook,m as createWebhook,h as defineHook,f as experimental_setAttributes,_ as getStepMetadata,a as getWorkflowMetadata,g as getWritable,v as resumeHook,d as sleep};
+import{c as e,i as t}from"../../_chunks/workflow/dist-6a3viBXZ.js";import{$n as n,Ht as r,Jn as i,Kt as a,Qt as o,Vt as s,Xt as c,Yn as l,Zn as u,Zt as d,t as f}from"../../_chunks/workflow/attribute-changes-DGVGRGfw.js";import{t as p}from"../../_chunks/workflow/sleep-CpXfoXLF.js";import{t as m}from"../../_chunks/workflow/run-BRdn7zy_.js";async function h(e,n={}){let r=f(e,n);if(r.length===0)return;let i=n.allowReservedAttributes===!0,a=globalThis[o];if(!a)throw new t("experimental_setAttributes() called outside a workflow runtime context. It must be called from within a workflow body (`use workflow`).");await a(r,i?{allowReservedAttributes:!0}:{})}r(s,m);function g(e){let t=globalThis[c];return t||l(`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 randomly generated. 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}=n();return o.url=`${s}/.well-known/workflow/v1/webhook/${encodeURIComponent(o.token)}`,o}function v(){function e(t,n){u(`defineHook().resume()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,e)}return{create(e){return g(e)},resume:e}}function y(e={}){let{namespace:t}=e,n=globalThis[d](t);return Object.create(globalThis.WritableStream.prototype,{[a]:{value:n,writable:!1}})}function b(){i(`getStepMetadata()`,`https://workflow-sdk.dev/docs/api-reference/workflow/get-step-metadata`,b)}function x(){u(`resumeHook()`,`https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook`,x)}export{t as FatalError,e as RetryableError,g as createHook,_ as createWebhook,v as defineHook,h as experimental_setAttributes,b as getStepMetadata,n as getWorkflowMetadata,y as getWritable,x as resumeHook,p as sleep};

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

@@ -24,6 +24,7 @@ export declare const EventTypeSchema: z.ZodEnum<{
     hook_received: "hook_received";
     run_started: "run_started";
     run_cancelled: "run_cancelled";
+    attr_set: "attr_set";
     step_started: "step_started";
     hook_disposed: "hook_disposed";
     hook_conflict: "hook_conflict";
@@ -43,6 +44,7 @@ export declare const BaseEventSchema: z.ZodObject<{
         hook_received: "hook_received";
         run_started: "run_started";
         run_cancelled: "run_cancelled";
+        attr_set: "attr_set";
         step_started: "step_started";
         hook_disposed: "hook_disposed";
         hook_conflict: "hook_conflict";
@@ -91,6 +93,8 @@ declare const RunCreatedEventSchema: z.ZodObject<{
         workflowName: z.ZodString;
         input: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -102,6 +106,8 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         workflowName: z.ZodString;
         input: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
@@ -112,6 +118,8 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         deploymentId: z.ZodOptional<z.ZodString>;
         workflowName: z.ZodOptional<z.ZodString>;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
@@ -132,6 +140,24 @@ export declare const CreateEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"run_cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    specVersion: z.ZodOptional<z.ZodNumber>;
+    eventType: z.ZodLiteral<"attr_set">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    eventData: z.ZodObject<{
+        changes: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        }, z.core.$strip>>;
+        writer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            stepId: z.ZodString;
+            attempt: z.ZodNumber;
+        }, z.core.$strip>], "type">;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"step_created">;
@@ -222,6 +248,8 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         workflowName: z.ZodString;
         input: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>]>;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
@@ -232,6 +260,8 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
         deploymentId: z.ZodOptional<z.ZodString>;
         workflowName: z.ZodOptional<z.ZodString>;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     correlationId: z.ZodOptional<z.ZodString>;
@@ -252,6 +282,24 @@ export declare const EventSchema: z.ZodIntersection<z.ZodDiscriminatedUnion<[z.Z
     correlationId: z.ZodOptional<z.ZodString>;
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"run_cancelled">;
+}, z.core.$strip>, z.ZodObject<{
+    specVersion: z.ZodOptional<z.ZodNumber>;
+    eventType: z.ZodLiteral<"attr_set">;
+    correlationId: z.ZodOptional<z.ZodString>;
+    eventData: z.ZodObject<{
+        changes: z.ZodArray<z.ZodObject<{
+            key: z.ZodString;
+            value: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        }, z.core.$strip>>;
+        writer: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"step">;
+            stepId: z.ZodString;
+            attempt: z.ZodNumber;
+        }, z.core.$strip>], "type">;
+        allowReservedAttributes: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     specVersion: z.ZodOptional<z.ZodNumber>;
     eventType: z.ZodLiteral<"step_created">;

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

@@ -16,7 +16,7 @@ export type * from './shared.js';
 export type { GetChunksOptions, StreamChunk, StreamChunksResponse, StreamInfoResponse, } from './shared.js';
 export { PaginatedResponseSchema, StructuredErrorSchema, } from './shared.js';
 export type { SpecVersion } from './spec-version.js';
-export { isLegacySpecVersion, requiresNewerWorld, SPEC_VERSION_CURRENT, SPEC_VERSION_LEGACY, SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT, SPEC_VERSION_SUPPORTS_EVENT_SOURCING, } 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_EVENT_SOURCING, } from './spec-version.js';
 export type * from './steps.js';
 export { StepSchema, StepStatusSchema } from './steps.js';
 export { DEFAULT_TIMESTAMP_THRESHOLD_FUTURE_MS, DEFAULT_TIMESTAMP_THRESHOLD_MS, DEFAULT_TIMESTAMP_THRESHOLD_PAST_MS, ulidToDate, validateUlidTimestamp, } from './ulid.js';

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

@@ -48,6 +48,7 @@ export declare const RunInputSchema: z.ZodObject<{
     workflowName: z.ZodString;
     specVersion: z.ZodNumber;
     executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type RunInput = z.infer<typeof RunInputSchema>;
 export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
@@ -67,6 +68,7 @@ export declare const WorkflowInvokePayloadSchema: z.ZodObject<{
         workflowName: z.ZodString;
         specVersion: z.ZodNumber;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const StepInvokePayloadSchema: z.ZodObject<{
@@ -105,6 +107,7 @@ export declare const QueuePayloadSchema: z.ZodUnion<readonly [z.ZodObject<{
         workflowName: z.ZodString;
         specVersion: z.ZodNumber;
         executionContext: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>>;
 }, z.core.$strip>, z.ZodObject<{
     workflowName: z.ZodString;

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

@@ -128,6 +128,8 @@ export interface CreateWorkflowRunRequest {
     input: SerializedData;
     executionContext?: SerializedData;
     specVersion?: number;
+    /** Plaintext attributes to seed when the run is created. */
+    attributes?: Record<string, string>;
 }
 export interface GetWorkflowRunParams {
     resolveData?: ResolveData;

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

@@ -19,7 +19,8 @@ export type SpecVersion = number & {
 export declare const SPEC_VERSION_LEGACY: SpecVersion;
 export declare const SPEC_VERSION_SUPPORTS_EVENT_SOURCING: SpecVersion;
 export declare const SPEC_VERSION_SUPPORTS_CBOR_QUEUE_TRANSPORT: SpecVersion;
-/** Current spec version (event-sourced architecture with CBOR queue transport). */
+export declare const SPEC_VERSION_SUPPORTS_ATTRIBUTES: SpecVersion;
+/** Current spec version (event-sourced architecture with native attributes). */
 export declare const SPEC_VERSION_CURRENT: SpecVersion;
 /**
  * Check if a spec version is legacy (<= SPEC_VERSION_LEGACY or undefined).