@workflow/core 4.2.0-beta.73 → 4.2.0-beta.75

package/dist/vm/uint8array-base64.js

@@ -0,0 +1,406 @@
+/**
+ * Polyfill for the TC39 Uint8Array base64/hex proposal (Stage 4).
+ *
+ * Implements:
+ *  - Uint8Array.prototype.toBase64([options])
+ *  - Uint8Array.prototype.toHex()
+ *  - Uint8Array.fromBase64(string[, options])
+ *  - Uint8Array.fromHex(string)
+ *  - Uint8Array.prototype.setFromBase64(string[, options])
+ *  - Uint8Array.prototype.setFromHex(string)
+ *
+ * @see https://tc39.es/proposal-arraybuffer-base64/spec/
+ */
+// Standard base64 alphabet
+const BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+// Reverse lookup table: char code -> index (for standard base64 alphabet)
+const BASE64_LOOKUP = new Uint8Array(128).fill(255);
+for (let i = 0; i < BASE64_CHARS.length; i++) {
+    BASE64_LOOKUP[BASE64_CHARS.charCodeAt(i)] = i;
+}
+// ASCII whitespace characters per spec: TAB, LF, FF, CR, SPACE
+function isAsciiWhitespace(code) {
+    return (code === 0x09 ||
+        code === 0x0a ||
+        code === 0x0c ||
+        code === 0x0d ||
+        code === 0x20);
+}
+function skipAsciiWhitespace(str, index) {
+    while (index < str.length && isAsciiWhitespace(str.charCodeAt(index))) {
+        index++;
+    }
+    return index;
+}
+function decodeBase64Chunk(chunk, throwOnExtraBits) {
+    const chunkLength = chunk.length;
+    let padded = chunk;
+    if (chunkLength === 2) {
+        padded = chunk + 'AA';
+    }
+    else if (chunkLength === 3) {
+        padded = chunk + 'A';
+    }
+    // Decode 4 base64 chars to 3 bytes
+    const b0 = BASE64_LOOKUP[padded.charCodeAt(0)];
+    const b1 = BASE64_LOOKUP[padded.charCodeAt(1)];
+    const b2 = BASE64_LOOKUP[padded.charCodeAt(2)];
+    const b3 = BASE64_LOOKUP[padded.charCodeAt(3)];
+    const byte0 = (b0 << 2) | (b1 >> 4);
+    const byte1 = ((b1 & 0x0f) << 4) | (b2 >> 2);
+    const byte2 = ((b2 & 0x03) << 6) | b3;
+    if (chunkLength === 2) {
+        if (throwOnExtraBits && byte1 !== 0) {
+            throw new SyntaxError('Extra bits in base64 chunk');
+        }
+        return [byte0];
+    }
+    if (chunkLength === 3) {
+        if (throwOnExtraBits && byte2 !== 0) {
+            throw new SyntaxError('Extra bits in base64 chunk');
+        }
+        return [byte0, byte1];
+    }
+    return [byte0, byte1, byte2];
+}
+function fromBase64(str, alphabet, lastChunkHandling, maxLength) {
+    if (maxLength === undefined) {
+        maxLength = Number.MAX_SAFE_INTEGER;
+    }
+    if (maxLength === 0) {
+        return { read: 0, bytes: [], error: null };
+    }
+    let read = 0;
+    const bytes = [];
+    let chunk = '';
+    let chunkLength = 0;
+    let index = 0;
+    const length = str.length;
+    while (true) {
+        index = skipAsciiWhitespace(str, index);
+        if (index === length) {
+            if (chunkLength > 0) {
+                if (lastChunkHandling === 'stop-before-partial') {
+                    return { read, bytes, error: null };
+                }
+                if (lastChunkHandling === 'loose') {
+                    if (chunkLength === 1) {
+                        return {
+                            read,
+                            bytes,
+                            error: new SyntaxError('Invalid base64: lone character in final chunk'),
+                        };
+                    }
+                    bytes.push(...decodeBase64Chunk(chunk, false));
+                }
+                else {
+                    // strict
+                    return {
+                        read,
+                        bytes,
+                        error: new SyntaxError('Invalid base64: incomplete chunk in strict mode'),
+                    };
+                }
+            }
+            return { read: length, bytes, error: null };
+        }
+        let char = str[index];
+        index++;
+        if (char === '=') {
+            if (chunkLength < 2) {
+                return {
+                    read,
+                    bytes,
+                    error: new SyntaxError('Invalid base64: padding in unexpected place'),
+                };
+            }
+            index = skipAsciiWhitespace(str, index);
+            if (chunkLength === 2) {
+                if (index === length) {
+                    if (lastChunkHandling === 'stop-before-partial') {
+                        return { read, bytes, error: null };
+                    }
+                    return {
+                        read,
+                        bytes,
+                        error: new SyntaxError('Invalid base64: missing second padding character'),
+                    };
+                }
+                char = str[index];
+                if (char === '=') {
+                    index = skipAsciiWhitespace(str, index + 1);
+                }
+            }
+            if (index < length) {
+                return {
+                    read,
+                    bytes,
+                    error: new SyntaxError('Invalid base64: unexpected characters after padding'),
+                };
+            }
+            const throwOnExtraBits = lastChunkHandling === 'strict';
+            try {
+                bytes.push(...decodeBase64Chunk(chunk, throwOnExtraBits));
+            }
+            catch (e) {
+                return { read, bytes, error: e };
+            }
+            return { read: length, bytes, error: null };
+        }
+        if (alphabet === 'base64url') {
+            if (char === '+' || char === '/') {
+                return {
+                    read,
+                    bytes,
+                    error: new SyntaxError(`Invalid base64url: unexpected character '${char}'`),
+                };
+            }
+            if (char === '-') {
+                char = '+';
+            }
+            else if (char === '_') {
+                char = '/';
+            }
+        }
+        // Validate character is in the standard base64 alphabet
+        const code = char.charCodeAt(0);
+        if (code >= 128 || BASE64_LOOKUP[code] === 255) {
+            return {
+                read,
+                bytes,
+                error: new SyntaxError(`Invalid base64: unexpected character '${str[index - 1]}'`),
+            };
+        }
+        // Check if adding this character would exceed maxLength
+        const remaining = maxLength - bytes.length;
+        if ((remaining === 1 && chunkLength === 2) ||
+            (remaining === 2 && chunkLength === 3)) {
+            return { read, bytes, error: null };
+        }
+        chunk += char;
+        chunkLength = chunk.length;
+        if (chunkLength === 4) {
+            bytes.push(...decodeBase64Chunk(chunk));
+            chunk = '';
+            chunkLength = 0;
+            read = index;
+            if (bytes.length === maxLength) {
+                return { read, bytes, error: null };
+            }
+        }
+    }
+}
+function fromHex(str, maxLength) {
+    if (maxLength === undefined) {
+        maxLength = Number.MAX_SAFE_INTEGER;
+    }
+    const length = str.length;
+    const bytes = [];
+    let read = 0;
+    if (length % 2 !== 0) {
+        return {
+            read: 0,
+            bytes: [],
+            error: new SyntaxError('Invalid hex: string length must be even'),
+        };
+    }
+    while (read < length && bytes.length < maxLength) {
+        const hexits = str.substring(read, read + 2);
+        if (!/^[0-9a-fA-F]{2}$/.test(hexits)) {
+            return {
+                read,
+                bytes,
+                error: new SyntaxError(`Invalid hex: unexpected character at position ${read}`),
+            };
+        }
+        read += 2;
+        bytes.push(Number.parseInt(hexits, 16));
+    }
+    return { read, bytes, error: null };
+}
+function toBase64(uint8, options) {
+    const alphabet = options?.alphabet ?? 'base64';
+    if (alphabet !== 'base64' && alphabet !== 'base64url') {
+        throw new TypeError(`Invalid alphabet: expected "base64" or "base64url", got "${alphabet}"`);
+    }
+    const omitPadding = Boolean(options?.omitPadding);
+    let result = '';
+    const len = uint8.length;
+    for (let i = 0; i < len; i += 3) {
+        const b0 = uint8[i];
+        const b1 = i + 1 < len ? uint8[i + 1] : 0;
+        const b2 = i + 2 < len ? uint8[i + 2] : 0;
+        result += BASE64_CHARS[(b0 >> 2) & 0x3f];
+        result += BASE64_CHARS[((b0 & 0x03) << 4) | ((b1 >> 4) & 0x0f)];
+        if (i + 1 < len) {
+            result += BASE64_CHARS[((b1 & 0x0f) << 2) | ((b2 >> 6) & 0x03)];
+        }
+        else if (!omitPadding) {
+            result += '=';
+        }
+        if (i + 2 < len) {
+            result += BASE64_CHARS[b2 & 0x3f];
+        }
+        else if (!omitPadding) {
+            result += '=';
+        }
+    }
+    if (alphabet === 'base64url') {
+        result = result.replace(/\+/g, '-').replace(/\//g, '_');
+    }
+    return result;
+}
+function toHex(uint8) {
+    let out = '';
+    for (let i = 0; i < uint8.length; i++) {
+        out += uint8[i].toString(16).padStart(2, '0');
+    }
+    return out;
+}
+/**
+ * Installs the Uint8Array base64/hex polyfill onto the given
+ * Uint8Array constructor and prototype. This is designed to be
+ * used inside the workflow VM context, operating on the VM's
+ * own Uint8Array rather than the host's.
+ */
+export function installUint8ArrayBase64(Uint8ArrayCtor) {
+    const proto = Uint8ArrayCtor.prototype;
+    const ctor = Uint8ArrayCtor;
+    // Uint8Array.prototype.toBase64([options])
+    if (!proto.toBase64) {
+        Object.defineProperty(proto, 'toBase64', {
+            value: function toBase64Method(options) {
+                if (!(this instanceof Uint8ArrayCtor)) {
+                    throw new TypeError('this is not a Uint8Array');
+                }
+                return toBase64(this, options);
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    // Uint8Array.prototype.toHex()
+    if (!proto.toHex) {
+        Object.defineProperty(proto, 'toHex', {
+            value: function toHexMethod() {
+                if (!(this instanceof Uint8ArrayCtor)) {
+                    throw new TypeError('this is not a Uint8Array');
+                }
+                return toHex(this);
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    // Uint8Array.prototype.setFromBase64(string[, options])
+    if (!proto.setFromBase64) {
+        Object.defineProperty(proto, 'setFromBase64', {
+            value: function setFromBase64Method(str, options) {
+                if (!(this instanceof Uint8ArrayCtor)) {
+                    throw new TypeError('this is not a Uint8Array');
+                }
+                if (typeof str !== 'string') {
+                    throw new TypeError('expected a string');
+                }
+                const alphabet = options?.alphabet ?? 'base64';
+                if (alphabet !== 'base64' && alphabet !== 'base64url') {
+                    throw new TypeError(`Invalid alphabet: expected "base64" or "base64url", got "${alphabet}"`);
+                }
+                const lastChunkHandling = options?.lastChunkHandling ?? 'loose';
+                if (lastChunkHandling !== 'loose' &&
+                    lastChunkHandling !== 'strict' &&
+                    lastChunkHandling !== 'stop-before-partial') {
+                    throw new TypeError(`Invalid lastChunkHandling: expected "loose", "strict", or "stop-before-partial", got "${lastChunkHandling}"`);
+                }
+                const result = fromBase64(str, alphabet, lastChunkHandling, this.length);
+                const bytes = result.bytes;
+                const written = bytes.length;
+                for (let i = 0; i < written; i++) {
+                    this[i] = bytes[i];
+                }
+                if (result.error) {
+                    throw result.error;
+                }
+                return { read: result.read, written };
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    // Uint8Array.prototype.setFromHex(string)
+    if (!proto.setFromHex) {
+        Object.defineProperty(proto, 'setFromHex', {
+            value: function setFromHexMethod(str) {
+                if (!(this instanceof Uint8ArrayCtor)) {
+                    throw new TypeError('this is not a Uint8Array');
+                }
+                if (typeof str !== 'string') {
+                    throw new TypeError('expected a string');
+                }
+                const result = fromHex(str, this.length);
+                const bytes = result.bytes;
+                const written = bytes.length;
+                for (let i = 0; i < written; i++) {
+                    this[i] = bytes[i];
+                }
+                if (result.error) {
+                    throw result.error;
+                }
+                return { read: result.read, written };
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    // Uint8Array.fromBase64(string[, options])
+    if (!ctor.fromBase64) {
+        Object.defineProperty(Uint8ArrayCtor, 'fromBase64', {
+            value: function fromBase64Static(str, options) {
+                if (typeof str !== 'string') {
+                    throw new TypeError('expected a string');
+                }
+                const alphabet = options?.alphabet ?? 'base64';
+                if (alphabet !== 'base64' && alphabet !== 'base64url') {
+                    throw new TypeError(`Invalid alphabet: expected "base64" or "base64url", got "${alphabet}"`);
+                }
+                const lastChunkHandling = options?.lastChunkHandling ?? 'loose';
+                if (lastChunkHandling !== 'loose' &&
+                    lastChunkHandling !== 'strict' &&
+                    lastChunkHandling !== 'stop-before-partial') {
+                    throw new TypeError(`Invalid lastChunkHandling: expected "loose", "strict", or "stop-before-partial", got "${lastChunkHandling}"`);
+                }
+                const result = fromBase64(str, alphabet, lastChunkHandling);
+                if (result.error) {
+                    throw result.error;
+                }
+                return new Uint8ArrayCtor(result.bytes);
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+    // Uint8Array.fromHex(string)
+    if (!ctor.fromHex) {
+        Object.defineProperty(Uint8ArrayCtor, 'fromHex', {
+            value: function fromHexStatic(str) {
+                if (typeof str !== 'string') {
+                    throw new TypeError('expected a string');
+                }
+                const result = fromHex(str);
+                if (result.error) {
+                    throw result.error;
+                }
+                return new Uint8ArrayCtor(result.bytes);
+            },
+            writable: true,
+            enumerable: false,
+            configurable: true,
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"uint8array-base64.js","sourceRoot":"","sources":["../../src/vm/uint8array-base64.ts"],"names":[],"mappings":"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"}

package/docs/api-reference/create-webhook.mdx

@@ -13,6 +13,10 @@ Creates a webhook that can be used to suspend and resume a workflow run upon rec
 
 Webhooks provide a way for external systems to send HTTP requests directly to your workflow. Unlike hooks which accept arbitrary payloads, webhooks work with standard HTTP `Request` objects and can return HTTP `Response` objects.
 
+<Callout type="warn">
+`createWebhook()` creates a public endpoint at `/.well-known/workflow/v1/webhook/:token`, and the token in that URL is the only authorization performed for incoming requests resuming that webhook. This is convenient for prototypes and simple resume links because it avoids creating another route, but if you need stronger security, prefer [`createHook()`](/docs/api-reference/workflow/create-hook) behind your own route and authorize the request before calling [`resumeHook()`](/docs/api-reference/workflow-api/resume-hook) to avoid unauthenticated workflow resumptions.
+</Callout>
+
 ```ts lineNumbers
 import { createWebhook } from "workflow"
 

package/docs/api-reference/index.mdx

@@ -20,7 +20,7 @@ npm i workflow
 
 ## Functions
 
-Workflow DevKit contains the following functions you can use inside your workflow functions:
+Workflow SDK contains the following functions you can use inside your workflow functions:
 
 <Cards>
     <Card href="/docs/api-reference/workflow/get-workflow-metadata" title="getWorkflowMetadata()">
@@ -51,7 +51,7 @@ Workflow DevKit contains the following functions you can use inside your workflo
 
 ## Error Classes
 
-Workflow DevKit includes error classes that can be thrown in a workflow or step to change the error exit strategy of a workflow.
+Workflow SDK includes error classes that can be thrown in a workflow or step to change the error exit strategy of a workflow.
 
 <Cards>
     <Card href="/docs/api-reference/workflow/fatal-error" title="FatalError()">

package/docs/foundations/errors-and-retries.mdx

@@ -10,7 +10,7 @@ related:
   - /docs/api-reference/workflow/retryable-error
 ---
 
-By default, errors thrown inside steps are retried. Additionally, Workflow DevKit provides two new types of errors you can use to customize retries.
+By default, errors thrown inside steps are retried. Additionally, Workflow SDK provides two new types of errors you can use to customize retries.
 
 ## Default Retrying
 

package/docs/foundations/hooks.mdx

@@ -219,7 +219,11 @@ While hooks are powerful, they require you to manually handle HTTP requests and
 2. Provides an automatically addressable `url` property pointing to the generated webhook endpoint
 3. Handles sending HTTP [`Response`](https://developer.mozilla.org/en-US/docs/Web/API/Response) objects back to the caller
 
-When using Workflow DevKit, webhooks are automatically wired up at `/.well-known/workflow/v1/webhook/:token` without any additional setup.
+When using Workflow SDK, webhooks are automatically wired up at `/.well-known/workflow/v1/webhook/:token` without any additional setup.
+
+<Callout type="warn">
+`createWebhook()` exposes a public route at `/.well-known/workflow/v1/webhook/:token`, and the token in that URL is the only authorization performed for incoming requests. This is convenient for prototypes and a simple developer experience because you can share the webhook URL (endpoint) without creating another route, but if you need stronger security, prefer [`createHook()`](/docs/api-reference/workflow/create-hook) behind your own route and authorize the request before calling [`resumeHook()`](/docs/api-reference/workflow-api/resume-hook) to avoid unauthenticated workflow resumptions.
+</Callout>
 
 <Callout type="info">
 See the full API reference for [`createWebhook()`](/docs/api-reference/workflow/create-webhook) for all available options.

package/docs/foundations/serialization.mdx

@@ -9,7 +9,7 @@ related:
   - /docs/errors/serialization-failed
 ---
 
-All function arguments and return values passed between workflow and step functions must be serializable. Workflow DevKit uses a custom serialization system built on top of [devalue](https://github.com/sveltejs/devalue). This system supports standard JSON types, as well as a few additional popular Web API types.
+All function arguments and return values passed between workflow and step functions must be serializable. Workflow SDK uses a custom serialization system built on top of [devalue](https://github.com/sveltejs/devalue). This system supports standard JSON types, as well as a few additional popular Web API types.
 
 <Callout type="info">
 The serialization system ensures that all data persists correctly across workflow suspensions and resumptions, enabling durable execution.
@@ -98,7 +98,7 @@ export async function handleWebhookWorkflow() {
 
 ### Using `fetch` in Workflows
 
-Because `Request` and `Response` are serializable, Workflow DevKit provides a `fetch` function that can be used directly in workflow functions:
+Because `Request` and `Response` are serializable, Workflow SDK provides a `fetch` function that can be used directly in workflow functions:
 
 ```typescript title="workflows/api-call.ts" lineNumbers
 import { fetch } from "workflow"; // [!code highlight]

package/docs/foundations/streaming.mdx

@@ -105,7 +105,7 @@ Because streams are live and continue receiving chunks, negative `startIndex` va
 
 ## Streams as Data Types
 
-[`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) and [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream) are standard Web Streams API types that Workflow DevKit makes serializable. These are not custom types - they follow the web standard - but Workflow DevKit adds the ability to pass them between functions while maintaining their streaming capabilities.
+[`ReadableStream`](https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream) and [`WritableStream`](https://developer.mozilla.org/en-US/docs/Web/API/WritableStream) are standard Web Streams API types that Workflow SDK makes serializable. These are not custom types - they follow the web standard - but Workflow SDK adds the ability to pass them between functions while maintaining their streaming capabilities.
 
 Unlike regular values that are fully serialized to the [event log](/docs/how-it-works/event-sourcing), streams maintain their streaming capabilities when passed between functions.
 
@@ -117,7 +117,7 @@ Unlike regular values that are fully serialized to the [event log](/docs/how-it-
 <Callout type="info">
 **How Streams Persist Across Workflow Suspensions**
 
-Streams in Workflow DevKit are backed by persistent, resumable storage provided by the "world" implementation. This is what enables streams to maintain their state even when workflows suspend and resume:
+Streams in Workflow SDK are backed by persistent, resumable storage provided by the "world" implementation. This is what enables streams to maintain their state even when workflows suspend and resume:
 
 - **Vercel deployments**: Streams are backed by a performant Redis-based stream
 - **Local development**: Stream chunks are stored in the filesystem
@@ -593,6 +593,7 @@ Stream errors don't trigger automatic retries for the producer step. Design your
 - [`sleep()` API Reference](/docs/api-reference/workflow/sleep) - Pause workflow execution for a duration
 - [`start()` API Reference](/docs/api-reference/workflow-api/start) - Start workflows and access the `Run` object
 - [`getRun()` API Reference](/docs/api-reference/workflow-api/get-run) - Retrieve runs and their streams later
+- [world.streams](/docs/api-reference/workflow-api/world/streams) - Low-level stream read/write/close via World SDK
 - [DurableAgent](/docs/api-reference/workflow-ai/durable-agent) - AI agents with built-in streaming support
 - [Errors and Retries](/docs/foundations/errors-and-retries) - Understanding error handling and retry behavior
 - [Serialization](/docs/foundations/serialization) - Understanding what data types can be passed in workflows

package/docs/foundations/workflows-and-steps.mdx

@@ -43,7 +43,7 @@ export async function processOrderWorkflow(orderId: string) {
 
 **Key Characteristics:**
 
-- Runs in a sandboxed environment without full Node.js access
+- Runs in a sandboxed environment without full Node.js access (see [Workflow Globals](/docs/api-reference/workflow-globals) for what's available)
 - All step results are persisted to the [event log](/docs/how-it-works/event-sourcing)
 - Must be **deterministic** to allow resuming after failures
 
@@ -203,5 +203,5 @@ While you can organize workflow and step functions however you like, we find tha
 You can choose to organize your steps into a single `steps.ts` file or separate files within a `steps` folder. The `shared` folder is a good place to put common steps that are used by multiple workflows.
 
 <Callout type="info">
-Splitting up steps and workflows will also help avoid most bundler related bugs with the Workflow DevKit.
+Splitting up steps and workflows will also help avoid most bundler related bugs with the Workflow SDK.
 </Callout>

package/docs/how-it-works/code-transform.mdx

@@ -1,6 +1,6 @@
 ---
 title: How the Directives Work
-description: Deep dive into the internals of how Workflow DevKit directives transform your code.
+description: Deep dive into the internals of how Workflow SDK directives transform your code.
 type: conceptual
 summary: Learn how the compiler transforms directive-annotated code into three execution modes.
 prerequisites:
@@ -10,10 +10,10 @@ related:
 ---
 
 <Callout>
-This is an advanced guide that dives into internals of the Workflow DevKit directive and is not required reading to use workflows. To simply use the Workflow DevKit, check out the [getting started](/docs/getting-started) guides for your framework.
+This is an advanced guide that dives into internals of the Workflow SDK directive and is not required reading to use workflows. To simply use the Workflow SDK, check out the [getting started](/docs/getting-started) guides for your framework.
 </Callout>
 
-Workflows use special directives to mark code for transformation by the Workflow DevKit compiler. This page explains how `"use workflow"` and `"use step"` directives work, what transformations are applied, and why they're necessary for durable execution.
+Workflows use special directives to mark code for transformation by the Workflow SDK compiler. This page explains how `"use workflow"` and `"use step"` directives work, what transformations are applied, and why they're necessary for durable execution.
 
 ## Directives Overview
 
@@ -210,7 +210,7 @@ The IDs are generated exactly like in workflow mode to ensure they can be direct
 
 ## Generated Files
 
-When you build your application, the Workflow DevKit generates three handler files in `.well-known/workflow/v1/`:
+When you build your application, the Workflow SDK generates three handler files in `.well-known/workflow/v1/`:
 
 ### `flow.js`
 
@@ -268,7 +268,7 @@ Contains webhook handling logic for delivering external data to running workflow
 
 ## Why Three Modes?
 
-The multi-mode transformation enables the Workflow DevKit's durable execution model:
+The multi-mode transformation enables the Workflow SDK's durable execution model:
 
 1. **Step Mode** (required) - Bundles executable step functions that can access the full runtime
 2. **Workflow Mode** (required) - Creates orchestration logic that can replay from event logs
@@ -320,7 +320,7 @@ The compiler generates stable IDs for workflows and steps based on file paths an
 - **Portable**: Works across different runtimes and deployments
 
 <Callout type="info">
-  Although IDs can change when files are moved or functions are renamed, Workflow DevKit function assume atomic versioning in the World. This means changing IDs won't break old workflows from running, but will prevent run from being upgraded and will cause your workflow/step names to change in the observability across deployments.
+  Although IDs can change when files are moved or functions are renamed, Workflow SDK function assume atomic versioning in the World. This means changing IDs won't break old workflows from running, but will prevent run from being upgraded and will cause your workflow/step names to change in the observability across deployments.
 </Callout>
 
 ## Framework Integration

package/docs/how-it-works/encryption.mdx

@@ -1,6 +1,6 @@
 ---
 title: Encryption
-description: Learn how Workflow DevKit encrypts user data end-to-end in the event log.
+description: Learn how Workflow SDK encrypts user data end-to-end in the event log.
 type: conceptual
 summary: Understand how workflow and step data is encrypted at rest.
 prerequisites:
@@ -11,10 +11,10 @@ related:
 ---
 
 <Callout>
-This guide explains how Workflow DevKit encrypts user data in the event log. Understanding these details is not required to use workflows — encryption is automatic and requires no code changes. For getting started, see the [getting started](/docs/getting-started) guides for your framework.
+This guide explains how Workflow SDK encrypts user data in the event log. Understanding these details is not required to use workflows — encryption is automatic and requires no code changes. For getting started, see the [getting started](/docs/getting-started) guides for your framework.
 </Callout>
 
-Workflow DevKit supports automatic end-to-end encryption of all user data before it is written to the event log. When a `World` implementation provides encryption support, it is safe to pass sensitive data — such as API keys, tokens, or user credentials — as workflow inputs, step arguments, and return values. The storage backend only ever sees ciphertext.
+Workflow SDK supports automatic end-to-end encryption of all user data before it is written to the event log. When a `World` implementation provides encryption support, it is safe to pass sensitive data — such as API keys, tokens, or user credentials — as workflow inputs, step arguments, and return values. The storage backend only ever sees ciphertext.
 
 Encryption support varies by `World` implementation. See the [Worlds](/worlds) page to check which worlds support this feature. `World` implementations opt into encryption by providing a `getEncryptionKeyForRun()` method — the core runtime will use it automatically when present.