@workflow/core 5.0.0-beta.30 → 5.0.0-beta.32

package/dist/set-attributes.d.ts

@@ -1,13 +1,18 @@
-import type { ExperimentalSetAttributesOptions } from './workflow/set-attributes.js';
-export type { ExperimentalSetAttributesOptions };
+import type { ExperimentalSetAttributesOptions, SetAttributesOptions } from './workflow/set-attributes.js';
+export type { ExperimentalSetAttributesOptions, SetAttributesOptions };
 /**
- * Host-side implementation for `experimental_setAttributes`. Workflow
- * bodies resolve to `./workflow/set-attributes.ts` via the `workflow`
- * package-exports condition; step bodies resolve here and can perform
- * the world write directly because they already run in host context.
+ * Host-side implementation for `setAttributes`. Workflow bodies resolve
+ * to `./workflow/set-attributes.ts` via the `workflow` package-exports
+ * condition; step bodies resolve here and can perform the world write
+ * directly because they already run in host context.
  *
  * Plain application code still has no active workflow run, so it throws
  * a clear `FatalError`.
  */
-export declare function experimental_setAttributes(attrs: Record<string, string | undefined>, options?: ExperimentalSetAttributesOptions): Promise<void>;
+export declare function setAttributes(attrs: Record<string, string | undefined>, options?: SetAttributesOptions): Promise<void>;
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export declare const experimental_setAttributes: typeof setAttributes;
 //# sourceMappingURL=set-attributes.d.ts.map

package/dist/set-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../src/set-attributes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,8BAA8B,CAAC;AAErF,YAAY,EAAE,gCAAgC,EAAE,CAAC;AAEjD;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,IAAI,CAAC,CA2Cf"}
+{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../src/set-attributes.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EACV,gCAAgC,EAChC,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AAEtC,YAAY,EAAE,gCAAgC,EAAE,oBAAoB,EAAE,CAAC;AAEvE;;;;;;;;GAQG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CA2Cf;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,sBAAgB,CAAC"}

package/dist/set-attributes.js

@@ -4,19 +4,19 @@ import { normalizeAttributeChanges } from './attribute-changes.js';
 import { getWorldLazy } from './runtime/get-world-lazy.js';
 import { contextStorage } from './step/context-storage.js';
 /**
- * Host-side implementation for `experimental_setAttributes`. Workflow
- * bodies resolve to `./workflow/set-attributes.ts` via the `workflow`
- * package-exports condition; step bodies resolve here and can perform
- * the world write directly because they already run in host context.
+ * Host-side implementation for `setAttributes`. Workflow bodies resolve
+ * to `./workflow/set-attributes.ts` via the `workflow` package-exports
+ * condition; step bodies resolve here and can perform the world write
+ * directly because they already run in host context.
  *
  * Plain application code still has no active workflow run, so it throws
  * a clear `FatalError`.
  */
-export async function experimental_setAttributes(attrs, options = {}) {
+export async function setAttributes(attrs, options = {}) {
     const store = contextStorage.getStore();
     const runId = store?.workflowMetadata?.workflowRunId;
     if (!runId) {
-        throw new FatalError("experimental_setAttributes() must be called from a 'use workflow' or 'use step' function. " +
+        throw new FatalError("setAttributes() must be called from a 'use workflow' or 'use step' function. " +
             'Calling it from plain host code is not supported.');
     }
     const changes = normalizeAttributeChanges(attrs, options);
@@ -53,4 +53,9 @@ export async function experimental_setAttributes(attrs, options = {}) {
         },
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export const experimental_setAttributes = setAttributes;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/step/context-storage.d.ts

@@ -55,7 +55,7 @@ export type StepContext = {
      * Turbo mode only: a promise that resolves once the backgrounded
      * `run_started` has landed (the run exists). Set when the step body runs
      * optimistically — before `run_started`/`step_started` are confirmed — so a
-     * direct step-body world write (e.g. `experimental_setAttributes`, which
+     * direct step-body world write (e.g. `setAttributes`, which
      * resolves to a host-side `attr_set` create) can gate on it and never race
      * ahead of the run's creation. `undefined` outside turbo and on the await
      * path, where `run_started` was already durable before the body ran.

package/dist/step/context-storage.js

@@ -19,4 +19,4 @@ const CONTEXT_STORAGE_SYMBOL = Symbol.for('WORKFLOW_STEP_CONTEXT_STORAGE');
 export const contextStorage = globalThis[CONTEXT_STORAGE_SYMBOL] ??
     (globalThis[CONTEXT_STORAGE_SYMBOL] =
         new AsyncLocalStorage());
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/version.d.ts

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

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by genversion.
-export const version = '5.0.0-beta.30';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjMwJ1xuIl19
+export const version = '5.0.0-beta.32';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDJCQUEyQjtBQUMzQixNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLy8gR2VuZXJhdGVkIGJ5IGdlbnZlcnNpb24uXG5leHBvcnQgY29uc3QgdmVyc2lvbiA9ICc1LjAuMC1iZXRhLjMyJ1xuIl19

package/dist/workflow/index.d.ts

@@ -1,11 +1,11 @@
 import type { StepMetadata } from '../step/get-step-metadata.js';
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
 export type { Hook, HookOptions } from '../create-hook.js';
-export { experimental_setAttributes } from './set-attributes.js';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';
 export { getWorkflowMetadata } from './get-workflow-metadata.js';
+export { experimental_setAttributes, type SetAttributesOptions, setAttributes, } from './set-attributes.js';
 export { getWritable } from './writable-stream.js';
 export declare function getStepMetadata(): StepMetadata;
 export declare function resumeHook(): void;

package/dist/workflow/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AACD,wBAAgB,UAAU,SAMzB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/workflow/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,YAAY,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,0BAA0B,EAC1B,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAInD,wBAAgB,eAAe,IAAI,YAAY,CAM9C;AACD,wBAAgB,UAAU,SAMzB"}

package/dist/workflow/index.js

@@ -1,10 +1,10 @@
 import { throwNotInStepContext, throwUnavailableInWorkflowContext, } from '../context-errors.js';
 export { FatalError, RetryableError, } from '@workflow/errors';
-export { experimental_setAttributes } from './set-attributes.js';
 export { sleep } from '../sleep.js';
 export { createHook, createWebhook } from './create-hook.js';
 export { defineHook } from './define-hook.js';
 export { getWorkflowMetadata } from './get-workflow-metadata.js';
+export { experimental_setAttributes, setAttributes, } from './set-attributes.js';
 export { getWritable } from './writable-stream.js';
 // workflows can't use these functions, but we still need to provide
 // the export so bundling doesn't fail when step and workflow are in same file
@@ -14,4 +14,4 @@ export function getStepMetadata() {
 export function resumeHook() {
     throwUnavailableInWorkflowContext('resumeHook()', 'https://workflow-sdk.dev/docs/api-reference/workflow-api/resume-hook', resumeHook);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHFCQUFxQixFQUNyQixpQ0FBaUMsR0FDbEMsTUFBTSxzQkFBc0IsQ0FBQztBQUc5QixPQUFPLEVBQ0wsVUFBVSxFQUNWLGNBQWMsR0FFZixNQUFNLGtCQUFrQixDQUFDO0FBRTFCLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxhQUFhLENBQUM7QUFDcEMsT0FBTyxFQUFFLFVBQVUsRUFBRSxhQUFhLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUM3RCxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFDOUMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sNEJBQTRCLENBQUM7QUFDakUsT0FBTyxFQUNMLDBCQUEwQixFQUUxQixhQUFhLEdBQ2QsTUFBTSxxQkFBcUIsQ0FBQztBQUM3QixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sc0JBQXNCLENBQUM7QUFFbkQsb0VBQW9FO0FBQ3BFLDhFQUE4RTtBQUM5RSxNQUFNLFVBQVUsZUFBZTtJQUM3QixxQkFBcUIsQ0FDbkIsbUJBQW1CLEVBQ25CLHdFQUF3RSxFQUN4RSxlQUFlLENBQ2hCLENBQUM7QUFDSixDQUFDO0FBQ0QsTUFBTSxVQUFVLFVBQVU7SUFDeEIsaUNBQWlDLENBQy9CLGNBQWMsRUFDZCxzRUFBc0UsRUFDdEUsVUFBVSxDQUNYLENBQUM7QUFDSixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgdGhyb3dOb3RJblN0ZXBDb250ZXh0LFxuICB0aHJvd1VuYXZhaWxhYmxlSW5Xb3JrZmxvd0NvbnRleHQsXG59IGZyb20gJy4uL2NvbnRleHQtZXJyb3JzLmpzJztcbmltcG9ydCB0eXBlIHsgU3RlcE1ldGFkYXRhIH0gZnJvbSAnLi4vc3RlcC9nZXQtc3RlcC1tZXRhZGF0YS5qcyc7XG5cbmV4cG9ydCB7XG4gIEZhdGFsRXJyb3IsXG4gIFJldHJ5YWJsZUVycm9yLFxuICB0eXBlIFJldHJ5YWJsZUVycm9yT3B0aW9ucyxcbn0gZnJvbSAnQHdvcmtmbG93L2Vycm9ycyc7XG5leHBvcnQgdHlwZSB7IEhvb2ssIEhvb2tPcHRpb25zIH0gZnJvbSAnLi4vY3JlYXRlLWhvb2suanMnO1xuZXhwb3J0IHsgc2xlZXAgfSBmcm9tICcuLi9zbGVlcC5qcyc7XG5leHBvcnQgeyBjcmVhdGVIb29rLCBjcmVhdGVXZWJob29rIH0gZnJvbSAnLi9jcmVhdGUtaG9vay5qcyc7XG5leHBvcnQgeyBkZWZpbmVIb29rIH0gZnJvbSAnLi9kZWZpbmUtaG9vay5qcyc7XG5leHBvcnQgeyBnZXRXb3JrZmxvd01ldGFkYXRhIH0gZnJvbSAnLi9nZXQtd29ya2Zsb3ctbWV0YWRhdGEuanMnO1xuZXhwb3J0IHtcbiAgZXhwZXJpbWVudGFsX3NldEF0dHJpYnV0ZXMsXG4gIHR5cGUgU2V0QXR0cmlidXRlc09wdGlvbnMsXG4gIHNldEF0dHJpYnV0ZXMsXG59IGZyb20gJy4vc2V0LWF0dHJpYnV0ZXMuanMnO1xuZXhwb3J0IHsgZ2V0V3JpdGFibGUgfSBmcm9tICcuL3dyaXRhYmxlLXN0cmVhbS5qcyc7XG5cbi8vIHdvcmtmbG93cyBjYW4ndCB1c2UgdGhlc2UgZnVuY3Rpb25zLCBidXQgd2Ugc3RpbGwgbmVlZCB0byBwcm92aWRlXG4vLyB0aGUgZXhwb3J0IHNvIGJ1bmRsaW5nIGRvZXNuJ3QgZmFpbCB3aGVuIHN0ZXAgYW5kIHdvcmtmbG93IGFyZSBpbiBzYW1lIGZpbGVcbmV4cG9ydCBmdW5jdGlvbiBnZXRTdGVwTWV0YWRhdGEoKTogU3RlcE1ldGFkYXRhIHtcbiAgdGhyb3dOb3RJblN0ZXBDb250ZXh0KFxuICAgICdnZXRTdGVwTWV0YWRhdGEoKScsXG4gICAgJ2h0dHBzOi8vd29ya2Zsb3ctc2RrLmRldi9kb2NzL2FwaS1yZWZlcmVuY2Uvd29ya2Zsb3cvZ2V0LXN0ZXAtbWV0YWRhdGEnLFxuICAgIGdldFN0ZXBNZXRhZGF0YVxuICApO1xufVxuZXhwb3J0IGZ1bmN0aW9uIHJlc3VtZUhvb2soKSB7XG4gIHRocm93VW5hdmFpbGFibGVJbldvcmtmbG93Q29udGV4dChcbiAgICAncmVzdW1lSG9vaygpJyxcbiAgICAnaHR0cHM6Ly93b3JrZmxvdy1zZGsuZGV2L2RvY3MvYXBpLXJlZmVyZW5jZS93b3JrZmxvdy1hcGkvcmVzdW1lLWhvb2snLFxuICAgIHJlc3VtZUhvb2tcbiAgKTtcbn1cbiJdfQ==

package/dist/workflow/set-attributes.d.ts

@@ -1,7 +1,7 @@
 /**
- * Options accepted by `experimental_setAttributes`.
+ * Options accepted by `setAttributes`.
  */
-export interface ExperimentalSetAttributesOptions {
+export interface SetAttributesOptions {
     /**
      * Permit attribute keys that start with the reserved `$` prefix.
      * **Default: `false`.**
@@ -20,14 +20,13 @@ export interface ExperimentalSetAttributesOptions {
      */
     allowReservedAttributes?: boolean;
 }
+/**
+ * @deprecated Use {@link SetAttributesOptions} instead.
+ */
+export type ExperimentalSetAttributesOptions = SetAttributesOptions;
 /**
  * Attach plaintext string key/value metadata to the current workflow run.
  *
- * **EXPERIMENTAL.** The `experimental_` prefix is deliberate — the
- * shape, semantics, and dispatch path are likely to change before this
- * is renamed to a stable export. Use only when you can absorb a
- * breaking rename later.
- *
  * Callable only from a workflow body (`'use workflow'`). The call is
  * dispatched as a native `attr_set` event and materialized on the run.
  *
@@ -41,33 +40,38 @@ export interface ExperimentalSetAttributesOptions {
  * trying to write a `$`-prefixed key throws `FatalError`. If you are a
  * framework author and need to set a reserved key, pass
  * `{ allowReservedAttributes: true }` as the second argument — see
- * `ExperimentalSetAttributesOptions` for the trade-offs.
+ * `SetAttributesOptions` for the trade-offs.
  *
- * **WARNING**: While this feature is experimental, calling e.g.
- * `Promise.all([experimental_setAttributes({ a: '1' }), experimental_setAttributes({ a: '2' })])`
+ * **WARNING**: Calling e.g.
+ * `Promise.all([setAttributes({ a: '1' }), setAttributes({ a: '2' })])`
  * is not guaranteed to be ordered consistently, but the equivalent
  * sequential `.then()` chain is.
  *
  * @example
  * ```ts
- * import { experimental_setAttributes } from 'workflow';
+ * import { setAttributes } from 'workflow';
  *
  * export async function myWorkflow() {
  *   'use workflow';
- *   await experimental_setAttributes({ phase: 'init' });
+ *   await setAttributes({ phase: 'init' });
  *   // ... work ...
- *   await experimental_setAttributes({ phase: 'done', orderId: 'ord_123' });
- *   await experimental_setAttributes({ orderId: undefined }); // remove
+ *   await setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await setAttributes({ orderId: undefined }); // remove
  * }
  * ```
  *
  * @example Framework / library code writing into the reserved namespace.
  * ```ts
- * await experimental_setAttributes(
+ * await setAttributes(
  *   { '$agent.kind': 'durable-agent' },
  *   { allowReservedAttributes: true }
  * );
  * ```
  */
-export declare function experimental_setAttributes(attrs: Record<string, string | undefined>, options?: ExperimentalSetAttributesOptions): Promise<void>;
+export declare function setAttributes(attrs: Record<string, string | undefined>, options?: SetAttributesOptions): Promise<void>;
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export declare const experimental_setAttributes: typeof setAttributes;
 //# sourceMappingURL=set-attributes.d.ts.map

package/dist/workflow/set-attributes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../../src/workflow/set-attributes.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,gCAAgC;IAC/C;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,gCAAqC,GAC7C,OAAO,CAAC,IAAI,CAAC,CAsBf"}
+{"version":3,"file":"set-attributes.d.ts","sourceRoot":"","sources":["../../src/workflow/set-attributes.ts"],"names":[],"mappings":"AAKA;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;;;;;;;;;;;;;;OAeG;IACH,uBAAuB,CAAC,EAAE,OAAO,CAAC;CACnC;AAED;;GAEG;AACH,MAAM,MAAM,gCAAgC,GAAG,oBAAoB,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,EACzC,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,sBAAgB,CAAC"}

package/dist/workflow/set-attributes.js

@@ -4,11 +4,6 @@ import { WORKFLOW_SET_ATTRIBUTES } from '../symbols.js';
 /**
  * Attach plaintext string key/value metadata to the current workflow run.
  *
- * **EXPERIMENTAL.** The `experimental_` prefix is deliberate — the
- * shape, semantics, and dispatch path are likely to change before this
- * is renamed to a stable export. Use only when you can absorb a
- * breaking rename later.
- *
  * Callable only from a workflow body (`'use workflow'`). The call is
  * dispatched as a native `attr_set` event and materialized on the run.
  *
@@ -22,44 +17,49 @@ import { WORKFLOW_SET_ATTRIBUTES } from '../symbols.js';
  * trying to write a `$`-prefixed key throws `FatalError`. If you are a
  * framework author and need to set a reserved key, pass
  * `{ allowReservedAttributes: true }` as the second argument — see
- * `ExperimentalSetAttributesOptions` for the trade-offs.
+ * `SetAttributesOptions` for the trade-offs.
  *
- * **WARNING**: While this feature is experimental, calling e.g.
- * `Promise.all([experimental_setAttributes({ a: '1' }), experimental_setAttributes({ a: '2' })])`
+ * **WARNING**: Calling e.g.
+ * `Promise.all([setAttributes({ a: '1' }), setAttributes({ a: '2' })])`
  * is not guaranteed to be ordered consistently, but the equivalent
  * sequential `.then()` chain is.
  *
  * @example
  * ```ts
- * import { experimental_setAttributes } from 'workflow';
+ * import { setAttributes } from 'workflow';
  *
  * export async function myWorkflow() {
  *   'use workflow';
- *   await experimental_setAttributes({ phase: 'init' });
+ *   await setAttributes({ phase: 'init' });
  *   // ... work ...
- *   await experimental_setAttributes({ phase: 'done', orderId: 'ord_123' });
- *   await experimental_setAttributes({ orderId: undefined }); // remove
+ *   await setAttributes({ phase: 'done', orderId: 'ord_123' });
+ *   await setAttributes({ orderId: undefined }); // remove
  * }
  * ```
  *
  * @example Framework / library code writing into the reserved namespace.
  * ```ts
- * await experimental_setAttributes(
+ * await setAttributes(
  *   { '$agent.kind': 'durable-agent' },
  *   { allowReservedAttributes: true }
  * );
  * ```
  */
-export async function experimental_setAttributes(attrs, options = {}) {
+export async function setAttributes(attrs, options = {}) {
     const changes = normalizeAttributeChanges(attrs, options);
     if (changes.length === 0)
         return;
     const allowReservedAttributes = options.allowReservedAttributes === true;
-    const setAttributes = globalThis[WORKFLOW_SET_ATTRIBUTES];
-    if (!setAttributes) {
-        throw new FatalError('experimental_setAttributes() called outside a workflow runtime context. ' +
+    const dispatchSetAttributes = globalThis[WORKFLOW_SET_ATTRIBUTES];
+    if (!dispatchSetAttributes) {
+        throw new FatalError('setAttributes() called outside a workflow runtime context. ' +
             'It must be called from within a workflow body (`use workflow`).');
     }
-    await setAttributes(changes, allowReservedAttributes ? { allowReservedAttributes: true } : {});
+    await dispatchSetAttributes(changes, allowReservedAttributes ? { allowReservedAttributes: true } : {});
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * @deprecated The feature is no longer experimental — use
+ * {@link setAttributes} instead.
+ */
+export const experimental_setAttributes = setAttributes;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2V0LWF0dHJpYnV0ZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvd29ya2Zsb3cvc2V0LWF0dHJpYnV0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBRTlDLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3BFLE9BQU8sRUFBRSx1QkFBdUIsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQThCeEQ7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7R0EyQ0c7QUFDSCxNQUFNLENBQUMsS0FBSyxVQUFVLGFBQWEsQ0FDakMsS0FBeUMsRUFDekMsVUFBZ0MsRUFBRTtJQUVsQyxNQUFNLE9BQU8sR0FBRyx5QkFBeUIsQ0FBQyxLQUFLLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDMUQsSUFBSSxPQUFPLENBQUMsTUFBTSxLQUFLLENBQUM7UUFBRSxPQUFPO0lBQ2pDLE1BQU0sdUJBQXVCLEdBQUcsT0FBTyxDQUFDLHVCQUF1QixLQUFLLElBQUksQ0FBQztJQUN6RSxNQUFNLHFCQUFxQixHQUFJLFVBQXNDLENBQ25FLHVCQUF1QixDQU1aLENBQUM7SUFDZCxJQUFJLENBQUMscUJBQXFCLEVBQUUsQ0FBQztRQUMzQixNQUFNLElBQUksVUFBVSxDQUNsQiw2REFBNkQ7WUFDM0QsaUVBQWlFLENBQ3BFLENBQUM7SUFDSixDQUFDO0lBQ0QsTUFBTSxxQkFBcUIsQ0FDekIsT0FBTyxFQUNQLHVCQUF1QixDQUFDLENBQUMsQ0FBQyxFQUFFLHVCQUF1QixFQUFFLElBQUksRUFBRSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQ2pFLENBQUM7QUFDSixDQUFDO0FBRUQ7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sMEJBQTBCLEdBQUcsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRmF0YWxFcnJvciB9IGZyb20gJ0B3b3JrZmxvdy9lcnJvcnMnO1xuaW1wb3J0IHR5cGUgeyBBdHRyaWJ1dGVDaGFuZ2UgfSBmcm9tICdAd29ya2Zsb3cvd29ybGQnO1xuaW1wb3J0IHsgbm9ybWFsaXplQXR0cmlidXRlQ2hhbmdlcyB9IGZyb20gJy4uL2F0dHJpYnV0ZS1jaGFuZ2VzLmpzJztcbmltcG9ydCB7IFdPUktGTE9XX1NFVF9BVFRSSUJVVEVTIH0gZnJvbSAnLi4vc3ltYm9scy5qcyc7XG5cbi8qKlxuICogT3B0aW9ucyBhY2NlcHRlZCBieSBgc2V0QXR0cmlidXRlc2AuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU2V0QXR0cmlidXRlc09wdGlvbnMge1xuICAvKipcbiAgICogUGVybWl0IGF0dHJpYnV0ZSBrZXlzIHRoYXQgc3RhcnQgd2l0aCB0aGUgcmVzZXJ2ZWQgYCRgIHByZWZpeC5cbiAgICogKipEZWZhdWx0OiBgZmFsc2VgLioqXG4gICAqXG4gICAqIFRoZSBgJGAgbmFtZXNwYWNlIGlzIHJlc2VydmVkIGZvciBmcmFtZXdvcmsgYW5kIGxpYnJhcnkgY29kZSB0aGF0XG4gICAqIGlzIGJ1aWx0IG9uIHRvcCBvZiB0aGUgd29ya2Zsb3cgU0RLICh0ZWxlbWV0cnksIGFnZW50IG1ldGFkYXRhLFxuICAgKiBwbGF0Zm9ybS1lbWl0dGVkIHRhZ3MsIGV0Yy4pLiBVc2VyIGNvZGUgTVVTVCBOT1Qgd3JpdGUga2V5cyBpblxuICAgKiB0aGlzIG5hbWVzcGFjZTsgdmFsaWRhdGlvbiByZWplY3RzIHRoZW0gc28gYWNjaWRlbnRhbCBjb2xsaXNpb25zXG4gICAqIHdpdGggdG9vbGluZy1vd25lZCBrZXlzIGNhbid0IHNsaXAgdGhyb3VnaC5cbiAgICpcbiAgICogT25seSBmbGlwIHRoaXMgdG8gYHRydWVgIGlmIHlvdXIgY2FsbGVyIGlzIGl0c2VsZiBhIGZyYW1ld29yayBvclxuICAgKiBsaWJyYXJ5IHRoYXQgb3ducyBhIGAkYC1wcmVmaXhlZCBzdWItbmFtZXNwYWNlIGFuZCBrbm93cyB0aGVcbiAgICogY29udmVudGlvbnMgb2YgYW55IG90aGVyIHRvb2xzIHdyaXRpbmcgaW50byBpdC4gTWlzdXNlIGNhblxuICAgKiBjb25mbGljdCB3aXRoIG9ic2VydmFiaWxpdHkgc3VyZmFjZXMsIGFnZW50IGRhc2hib2FyZHMsIG9yIGZ1dHVyZVxuICAgKiBwbGF0Zm9ybSBmZWF0dXJlcyB0aGF0IHJlbHkgb24gdGhlIHJlc2VydmVkIG5hbWVzcGFjZS5cbiAgICovXG4gIGFsbG93UmVzZXJ2ZWRBdHRyaWJ1dGVzPzogYm9vbGVhbjtcbn1cblxuLyoqXG4gKiBAZGVwcmVjYXRlZCBVc2Uge0BsaW5rIFNldEF0dHJpYnV0ZXNPcHRpb25zfSBpbnN0ZWFkLlxuICovXG5leHBvcnQgdHlwZSBFeHBlcmltZW50YWxTZXRBdHRyaWJ1dGVzT3B0aW9ucyA9IFNldEF0dHJpYnV0ZXNPcHRpb25zO1xuXG4vKipcbiAqIEF0dGFjaCBwbGFpbnRleHQgc3RyaW5nIGtleS92YWx1ZSBtZXRhZGF0YSB0byB0aGUgY3VycmVudCB3b3JrZmxvdyBydW4uXG4gKlxuICogQ2FsbGFibGUgb25seSBmcm9tIGEgd29ya2Zsb3cgYm9keSAoYCd1c2Ugd29ya2Zsb3cnYCkuIFRoZSBjYWxsIGlzXG4gKiBkaXNwYXRjaGVkIGFzIGEgbmF0aXZlIGBhdHRyX3NldGAgZXZlbnQgYW5kIG1hdGVyaWFsaXplZCBvbiB0aGUgcnVuLlxuICpcbiAqIFZhbGlkYXRpb24gcnVucyBpbiB0aGUgVk0gKGNoZWFwLCBkZXRlcm1pbmlzdGljKSBiZWZvcmUgZXZlbnRcbiAqIGRpc3BhdGNoIC0gdmlvbGF0aW9ucyB0aHJvdyBgRmF0YWxFcnJvcmAgd2l0aG91dCB3cml0aW5nIGFuIGV2ZW50LiBBblxuICogZW1wdHkgcmVjb3JkIGlzIGEgbm8tb3AuIGB2YWx1ZTogdW5kZWZpbmVkYCByZW1vdmVzIHRoZSBrZXkgZnJvbSB0aGVcbiAqIHJ1bidzIGF0dHJpYnV0ZSBtYXAuXG4gKlxuICogKipSZXNlcnZlZCBuYW1lc3BhY2UuKiogS2V5cyBzdGFydGluZyB3aXRoIGAkYCBhcmUgcmVzZXJ2ZWQgZm9yXG4gKiBmcmFtZXdvcmsvbGlicmFyeSBjb2RlICh0ZWxlbWV0cnksIGFnZW50IG1ldGFkYXRhLCBldGMuKS4gVXNlciBjb2RlXG4gKiB0cnlpbmcgdG8gd3JpdGUgYSBgJGAtcHJlZml4ZWQga2V5IHRocm93cyBgRmF0YWxFcnJvcmAuIElmIHlvdSBhcmUgYVxuICogZnJhbWV3b3JrIGF1dGhvciBhbmQgbmVlZCB0byBzZXQgYSByZXNlcnZlZCBrZXksIHBhc3NcbiAqIGB7IGFsbG93UmVzZXJ2ZWRBdHRyaWJ1dGVzOiB0cnVlIH1gIGFzIHRoZSBzZWNvbmQgYXJndW1lbnQg4oCUIHNlZVxuICogYFNldEF0dHJpYnV0ZXNPcHRpb25zYCBmb3IgdGhlIHRyYWRlLW9mZnMuXG4gKlxuICogKipXQVJOSU5HKio6IENhbGxpbmcgZS5nLlxuICogYFByb21pc2UuYWxsKFtzZXRBdHRyaWJ1dGVzKHsgYTogJzEnIH0pLCBzZXRBdHRyaWJ1dGVzKHsgYTogJzInIH0pXSlgXG4gKiBpcyBub3QgZ3VhcmFudGVlZCB0byBiZSBvcmRlcmVkIGNvbnNpc3RlbnRseSwgYnV0IHRoZSBlcXVpdmFsZW50XG4gKiBzZXF1ZW50aWFsIGAudGhlbigpYCBjaGFpbiBpcy5cbiAqXG4gKiBAZXhhbXBsZVxuICogYGBgdHNcbiAqIGltcG9ydCB7IHNldEF0dHJpYnV0ZXMgfSBmcm9tICd3b3JrZmxvdyc7XG4gKlxuICogZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIG15V29ya2Zsb3coKSB7XG4gKiAgICd1c2Ugd29ya2Zsb3cnO1xuICogICBhd2FpdCBzZXRBdHRyaWJ1dGVzKHsgcGhhc2U6ICdpbml0JyB9KTtcbiAqICAgLy8gLi4uIHdvcmsgLi4uXG4gKiAgIGF3YWl0IHNldEF0dHJpYnV0ZXMoeyBwaGFzZTogJ2RvbmUnLCBvcmRlcklkOiAnb3JkXzEyMycgfSk7XG4gKiAgIGF3YWl0IHNldEF0dHJpYnV0ZXMoeyBvcmRlcklkOiB1bmRlZmluZWQgfSk7IC8vIHJlbW92ZVxuICogfVxuICogYGBgXG4gKlxuICogQGV4YW1wbGUgRnJhbWV3b3JrIC8gbGlicmFyeSBjb2RlIHdyaXRpbmcgaW50byB0aGUgcmVzZXJ2ZWQgbmFtZXNwYWNlLlxuICogYGBgdHNcbiAqIGF3YWl0IHNldEF0dHJpYnV0ZXMoXG4gKiAgIHsgJyRhZ2VudC5raW5kJzogJ2R1cmFibGUtYWdlbnQnIH0sXG4gKiAgIHsgYWxsb3dSZXNlcnZlZEF0dHJpYnV0ZXM6IHRydWUgfVxuICogKTtcbiAqIGBgYFxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gc2V0QXR0cmlidXRlcyhcbiAgYXR0cnM6IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IHVuZGVmaW5lZD4sXG4gIG9wdGlvbnM6IFNldEF0dHJpYnV0ZXNPcHRpb25zID0ge31cbik6IFByb21pc2U8dm9pZD4ge1xuICBjb25zdCBjaGFuZ2VzID0gbm9ybWFsaXplQXR0cmlidXRlQ2hhbmdlcyhhdHRycywgb3B0aW9ucyk7XG4gIGlmIChjaGFuZ2VzLmxlbmd0aCA9PT0gMCkgcmV0dXJuO1xuICBjb25zdCBhbGxvd1Jlc2VydmVkQXR0cmlidXRlcyA9IG9wdGlvbnMuYWxsb3dSZXNlcnZlZEF0dHJpYnV0ZXMgPT09IHRydWU7XG4gIGNvbnN0IGRpc3BhdGNoU2V0QXR0cmlidXRlcyA9IChnbG9iYWxUaGlzIGFzIFJlY29yZDxzeW1ib2wsIHVua25vd24+KVtcbiAgICBXT1JLRkxPV19TRVRfQVRUUklCVVRFU1xuICBdIGFzXG4gICAgfCAoKFxuICAgICAgICBjaGFuZ2VzOiBBdHRyaWJ1dGVDaGFuZ2VbXSxcbiAgICAgICAgb3B0aW9ucz86IHsgYWxsb3dSZXNlcnZlZEF0dHJpYnV0ZXM/OiBib29sZWFuIH1cbiAgICAgICkgPT4gUHJvbWlzZTx2b2lkPilcbiAgICB8IHVuZGVmaW5lZDtcbiAgaWYgKCFkaXNwYXRjaFNldEF0dHJpYnV0ZXMpIHtcbiAgICB0aHJvdyBuZXcgRmF0YWxFcnJvcihcbiAgICAgICdzZXRBdHRyaWJ1dGVzKCkgY2FsbGVkIG91dHNpZGUgYSB3b3JrZmxvdyBydW50aW1lIGNvbnRleHQuICcgK1xuICAgICAgICAnSXQgbXVzdCBiZSBjYWxsZWQgZnJvbSB3aXRoaW4gYSB3b3JrZmxvdyBib2R5IChgdXNlIHdvcmtmbG93YCkuJ1xuICAgICk7XG4gIH1cbiAgYXdhaXQgZGlzcGF0Y2hTZXRBdHRyaWJ1dGVzKFxuICAgIGNoYW5nZXMsXG4gICAgYWxsb3dSZXNlcnZlZEF0dHJpYnV0ZXMgPyB7IGFsbG93UmVzZXJ2ZWRBdHRyaWJ1dGVzOiB0cnVlIH0gOiB7fVxuICApO1xufVxuXG4vKipcbiAqIEBkZXByZWNhdGVkIFRoZSBmZWF0dXJlIGlzIG5vIGxvbmdlciBleHBlcmltZW50YWwg4oCUIHVzZVxuICoge0BsaW5rIHNldEF0dHJpYnV0ZXN9IGluc3RlYWQuXG4gKi9cbmV4cG9ydCBjb25zdCBleHBlcmltZW50YWxfc2V0QXR0cmlidXRlcyA9IHNldEF0dHJpYnV0ZXM7XG4iXX0=

package/docs/api-reference/index.mdx

@@ -47,8 +47,8 @@ Workflow SDK contains the following functions you can use inside your workflow f
     <Card href="/docs/api-reference/workflow/get-writable" title="getWritable()">
         Access the current workflow run's default stream.
     </Card>
-    <Card href="/docs/api-reference/workflow/experimental-set-attributes" title="experimental_setAttributes()">
-        Attach experimental string metadata to the current workflow run.
+    <Card href="/docs/api-reference/workflow/set-attributes" title="setAttributes()">
+        Attach string metadata to the current workflow run.
     </Card>
 </Cards>
 

package/docs/api-reference/{experimental-set-attributes.mdx → set-attributes.mdx}

@@ -1,8 +1,8 @@
 ---
-title: experimental_setAttributes
+title: setAttributes
 description: Attach string metadata to workflow run for observability.
 type: reference
-summary: Use experimental_setAttributes inside a workflow or step function to set run attributes.
+summary: Use setAttributes inside a workflow or step function to set run attributes.
 prerequisites:
   - /docs/foundations/workflows-and-steps
 related:
@@ -12,17 +12,13 @@ related:
 
 Attaches string metadata to the current workflow run.
 
-<Callout>
-This API is experimental and may change before the stable attributes API is released.
-</Callout>
-
 ```typescript lineNumbers
-import { experimental_setAttributes } from "workflow"
+import { setAttributes } from "workflow"
 
 export async function orderWorkflow(orderId: string) {
   "use workflow"
 
-  await experimental_setAttributes({
+  await setAttributes({
     phase: "received",
     orderId,
   })
@@ -35,24 +31,24 @@ export async function orderWorkflow(orderId: string) {
 
 <TSDoc
 definition={`
-import { experimental_setAttributes } from "workflow";
-export default experimental_setAttributes;`}
+import { setAttributes } from "workflow";
+export default setAttributes;`}
 showSections={['parameters']}
 />
 
 ## Usage
 
-Call `experimental_setAttributes` from a `"use workflow"` function or a `"use step"` function. Calling it from plain application code is not supported because there is no active workflow run.
+Call `setAttributes` from a `"use workflow"` function or a `"use step"` function. Calling it from plain application code is not supported because there is no active workflow run.
 
 Attribute values must be strings. Pass `undefined` to remove an attribute:
 
 ```typescript lineNumbers
-import { experimental_setAttributes } from "workflow"
+import { setAttributes } from "workflow"
 
 export async function cleanupAttributes() {
   "use workflow"
 
-  await experimental_setAttributes({ staleKey: undefined })
+  await setAttributes({ staleKey: undefined })
 }
 ```
 
@@ -62,4 +58,8 @@ Validation errors throw [`FatalError`](/docs/api-reference/workflow/fatal-error)
 
 Calls from both workflow and step bodies append a native `attr_set` event, which the World materializes onto `run.attributes`. Workflow-originated events record a workflow writer; step-originated events record the originating step ID and attempt.
 
-Native attributes require spec version 4 or later. Step-body storage errors throw from `experimental_setAttributes`; catch them inside the step if the write should be best-effort. Workflow-body writes are committed when the workflow suspends: transient storage errors are retried with the suspension, while a write the World rejects as invalid — such as exceeding the per-run attribute cap across multiple calls — fails the run with the validation error.
+Native attributes require spec version 4 or later. Step-body storage errors throw from `setAttributes`; catch them inside the step if the write should be best-effort. Workflow-body writes are committed when the workflow suspends: transient storage errors are retried with the suspension, while a write the World rejects as invalid — such as exceeding the per-run attribute cap across multiple calls — fails the run with the validation error.
+
+<Callout>
+This function was previously exported as `experimental_setAttributes`. The old name still works as a deprecated alias — update imports to `setAttributes`.
+</Callout>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@workflow/core",
-  "version": "5.0.0-beta.30",
+  "version": "5.0.0-beta.32",
   "description": "Core runtime and engine for Workflow SDK",
   "type": "module",
   "main": "dist/index.js",
@@ -101,9 +101,9 @@
     "@workflow/errors": "5.0.0-beta.10",
     "@workflow/serde": "5.0.0-beta.2",
     "@workflow/utils": "5.0.0-beta.6",
-    "@workflow/world": "5.0.0-beta.18",
-    "@workflow/world-local": "5.0.0-beta.26",
-    "@workflow/world-vercel": "5.0.0-beta.26"
+    "@workflow/world": "5.0.0-beta.19",
+    "@workflow/world-local": "5.0.0-beta.27",
+    "@workflow/world-vercel": "5.0.0-beta.28"
   },
   "devDependencies": {
     "@opentelemetry/api": "1.9.0",