eve 0.48.0 → 0.49.1

package/dist/src/compiled/@workflow/core/sealed-box.d.ts

@@ -3,7 +3,7 @@ import { type CryptoKey } from './encryption.js';
  * A per-run X25519 keypair, derived from the run's key material.
  *
  * Callers should derive this once per run and memoize it alongside the
- * symmetric key — derivation costs several Web Crypto round trips.
+ * symmetric key, since derivation costs several Web Crypto round trips.
  */
 export interface RunKeyPair {
     /** Raw 32-byte X25519 private scalar. Secret. */
@@ -41,7 +41,7 @@ export declare function bytesToBase64(bytes: Uint8Array): string;
  * symmetric path) rather than crash a resumption.
  *
  * Validation is strict, because a lenient decoder is worse than a throwing one
- * here — silently returning a short or truncated key makes a corrupt value look
+ * here: silently returning a short or truncated key makes a corrupt value look
  * *present*, so the caller seals to garbage instead of taking the fallback.
  * Rejected: characters outside the alphabet, a length that cannot describe a
  * whole number of bytes (`length % 4 === 1`), padding anywhere but the end, and
@@ -52,7 +52,7 @@ export declare function base64ToBytes(value: string): Uint8Array | undefined;
  * The writer half of the KEM: generate an ephemeral keypair and derive a
  * content key for a recipient's public key.
  *
- * Use this when many payloads share one KEM operation — i.e. stream frames.
+ * Use this when many payloads share one KEM operation, i.e. stream frames.
  * The returned `contentKey` can only encrypt, so a stream writer provably
  * cannot read the recipient run's data even by mistake.
  *
@@ -83,7 +83,7 @@ export declare function decapsulate(keyPair: RunKeyPair, ephemeralPublicKey: Uin
  * Seal a payload to a run's public key.
  *
  * Each call performs its own KEM operation, so every sealed payload gets an
- * independent content key — nonce reuse across calls is impossible by
+ * independent content key: nonce reuse across calls is impossible by
  * construction.
  *
  * @param recipientPublicKey - The recipient run's raw 32-byte X25519 public key
@@ -105,7 +105,7 @@ export declare function seal(recipientPublicKey: Uint8Array, data: Uint8Array, a
 export declare function open(keyPair: RunKeyPair, sealed: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 /**
  * A writer-side session that amortizes one KEM operation across many sealed
- * payloads — use it for streams, where one-shot {@link seal} would perform a
+ * payloads. Use it for streams, where one-shot {@link seal} would perform a
  * fresh keygen + ECDH + HKDF for every frame.
  *
  * Safety rests on two properties:
@@ -129,7 +129,7 @@ export declare function createSealSession(recipientPublicKey: Uint8Array, aad?:
  * The mirror of {@link createSealSession}: because every frame from one writer
  * carries the same ephemeral public key, this turns an ECDH per frame into an
  * ECDH per writer. Correctness does not depend on the writer having used a
- * session — a stream of independently sealed payloads simply misses the cache
+ * session: a stream of independently sealed payloads misses the cache
  * on each new ephemeral key.
  *
  * The cache is keyed by the ephemeral public key and holds one entry, which is
@@ -151,7 +151,7 @@ export declare function createOpenSession(keyPair: RunKeyPair, aad?: Uint8Array)
  * `ephemeralPublicKey ‖ recipientPublicKey`, and a recipient public key is
  * unique per (deployment key × project × run). Replaying a sealed payload at
  * a different run therefore fails at key agreement regardless. AAD is
- * available for callers that want an additional, KDF-independent binding —
+ * available for callers that want an additional, KDF-independent binding:
  * both sides must supply byte-identical values or the payload will not open.
  */
 export declare function runAad(projectId: string, runId: string): Uint8Array;

package/dist/src/compiled/@workflow/core/serialization/codec-devalue-vm.d.ts

@@ -6,7 +6,7 @@
  */
 import type { Codec } from './codec.js';
 /**
- * The workflow-mode reducer/reviver key sets — exported for the QuickJS
+ * The workflow-mode reducer/reviver key sets, exported for the QuickJS
  * host serde's exhaustiveness test (quickjs-serde.test.ts), which pins
  * that the handle-space codec implements exactly these.
  */

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

@@ -5,7 +5,7 @@
  * reducers (serialize) and revivers (deserialize) which are composed
  * internally based on the serialization mode.
  *
- * The reducer/reviver pattern is specific to devalue — other codecs
+ * The reducer/reviver pattern is specific to devalue: other codecs
  * (CBOR, JSON) would handle types differently (e.g. CBOR supports Date,
  * typed arrays, Map, Set natively).
  */

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

@@ -3,7 +3,7 @@
  *
  * A codec handles the core serialize/deserialize logic for a specific
  * wire format (devalue, CBOR, JSON, etc.). Each codec is responsible
- * for handling all supported data types internally — the caller only
+ * for handling all supported data types internally; the caller only
  * specifies which serialization mode to use.
  *
  * - **devalue**: Uses custom reducers/revivers for Date, Error, Map, Set,
@@ -70,15 +70,15 @@ export interface CodecOptions {
     compressionStats?: CompressionStats;
     /**
      * Optional sink populated by the hardened serializer with every
-     * workflow (guest) code execution that serialization could not avoid —
+     * workflow (guest) code execution that serialization could not avoid:
      * getters, proxies, and custom `[WORKFLOW_SERIALIZE]` methods. A non-empty
      * `executions` array means serialization may have perturbed VM state
      * (it runs exactly once per payload and is never replayed, so any side
      * effect it triggers diverges from replay).
      *
      * Every dehydrate path already reports this as span attributes. Passing a
-     * sink is for callers that need the executions *programmatically* — a
-     * retained-VM gate deciding whether the VM is still reusable. No caller
+     * sink is for callers that need the executions *programmatically*, such
+     * as a retained-VM gate deciding whether the VM is still reusable. No caller
      * does that yet, so nothing in the runtime currently passes one.
      *
      * Serialize side only.

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

@@ -5,22 +5,23 @@
  * format prefix system to mark compressed data (e.g. 'zstd' or 'gzip'
  * wrapping the inner format: 'zstd' + zstd('devl' + payload)).
  *
- * Codec selection (write side): zstd is preferred — it is markedly faster
- * than gzip at a comparable-or-better ratio (see scripts/README.md), and
- * compression runs at every step boundary so the write CPU is a per-step
- * tax. zstd requires `node:zlib` >= 22.15 (Web `CompressionStream` has no
- * zstd), so on a runtime without it we fall back to gzip via the portable
+ * Codec selection (write side): zstd is preferred because it is markedly
+ * faster than gzip at a comparable-or-better ratio (see scripts/README.md),
+ * and compression runs at every step boundary so the write CPU is a
+ * per-step tax. zstd requires `node:zlib` >= 22.15 (Web
+ * `CompressionStream` has no zstd), so on a runtime without it we fall back
+ * to gzip via the portable
  * `CompressionStream`. `WORKFLOW_COMPRESSION_CODEC=gzip` forces the
  * portable codec.
  *
  * Read side: dispatch on the format prefix, so both 'zstd' and 'gzip'
  * payloads are always decodable regardless of which codec wrote them.
- * (The browser o11y read path decodes zstd via a registered WASM decoder —
+ * (The browser o11y read path decodes zstd via a registered WASM decoder,
  * see `serialization-format.ts`; this module's `decompress` is the Node
  * runtime/replay path and uses `node:zlib`.)
  *
  * Layering order with encryption: compression is applied BEFORE
- * encryption (encr(zstd(devl))) — encrypted bytes are high-entropy and
+ * encryption (encr(zstd(devl))): encrypted bytes are high-entropy and
  * do not compress, so the reverse order would be a no-op.
  *
  * Compression is conditional:
@@ -50,8 +51,8 @@ export type CompressionCodec = 'zstd' | 'gzip' | 'none';
  * Telemetry sink describing what the compression layer did to a payload.
  * Populated by {@link compress} (write) and {@link decompress} (read) when
  * a `stats` object is passed. Sizes are measured at the compression
- * boundary — i.e. before encryption is layered on the write side and after
- * decryption on the read side — so they reflect compression's effect, not
+ * boundary (i.e. before encryption is layered on the write side and after
+ * decryption on the read side), so they reflect compression's effect, not
  * the at-rest size (which also includes the `encr` envelope and, on some
  * backends, base64 expansion).
  *
@@ -80,8 +81,8 @@ export interface CompressionStats {
  * @param data - The format-prefixed serialized data (e.g. 'devl' + bytes)
  * @param enabled - Whether the target run supports compressed payloads
  *   (run specVersion >= SPEC_VERSION_SUPPORTS_COMPRESSION, and for
- *   cross-deployment writes, the target deployment's capabilities —
- *   see `getRunCapabilities` in capabilities.ts). zstd and gzip read
+ *   cross-deployment writes, the target deployment's capabilities; see
+ *   `getRunCapabilities` in capabilities.ts). zstd and gzip read
  *   support co-ship, so a single boolean is sufficient.
  * @param stats - Optional telemetry sink; populated when `data` is binary.
  * @returns The compressed data with a codec prefix, or the original data

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

@@ -21,7 +21,7 @@ declare const RUN_KEYS_BRAND: unique symbol;
 /**
  * A write-only capability: seal payloads to a run's X25519 public key.
  *
- * This is what a *cross-run* writer holds — a hook resumption targeting
+ * This is what a *cross-run* writer holds: a hook resumption targeting
  * another run, or a child workflow writing into a parent's forwarded stream.
  * It carries no ability to decrypt anything, and because it is a distinct
  * nominal type it cannot be mistaken for symmetric key material.
@@ -47,9 +47,9 @@ export interface SealTarget {
  */
 export interface RunPayloadKeys {
     readonly [RUN_KEYS_BRAND]: true;
-    /** Symmetric AES-256-GCM key — the run's own `encr` payloads. */
+    /** Symmetric AES-256-GCM key: the run's own `encr` payloads. */
     readonly aes: CryptoKey;
-    /** X25519 keypair — opens `encp` payloads sealed to this run. */
+    /** X25519 keypair: opens `encp` payloads sealed to this run. */
     readonly keyPair: RunKeyPair;
     /** Additional authenticated data expected on sealed payloads. */
     readonly aad?: Uint8Array;
@@ -66,7 +66,7 @@ export interface RunPayloadKeys {
  * | ------------------ | ------- | -------------- | ------------------------ |
  * | `CryptoKey`        | `encr`  | `encr`         | same-run (legacy shape)  |
  * | {@link RunPayloadKeys} | `encr`  | `encr`, `encp` | the owning run, o11y     |
- * | {@link SealTarget} | `encp`  | —              | cross-run writers        |
+ * | {@link SealTarget} | `encp`  | (none)         | cross-run writers        |
  *
  * A run's own payloads deliberately stay symmetric even when the writer could
  * seal: sealing costs a fresh ECDH per envelope and 32 extra bytes, and buys
@@ -96,7 +96,7 @@ export declare function sealTo(recipientPublicKey: Uint8Array, aad?: Uint8Array)
  */
 export declare function runPayloadKeys(aes: CryptoKey, keyPair: RunKeyPair, aad?: Uint8Array): RunPayloadKeys;
 /**
- * Build the full key capability for a run from its raw 32-byte key material —
+ * Build the full key capability for a run from its raw 32-byte key material,
  * the value `World.getEncryptionKeyForRun()` returns.
  *
  * Use this anywhere a run reads its own event log: it yields a key that opens
@@ -122,8 +122,8 @@ export declare function resolveEncryptionKey(key: EncryptionKeyParam): Promise<P
  * Encrypt a format-prefixed payload if a key is provided.
  *
  * Wraps the data with the `encr` prefix for symmetric keys, or the `encp`
- * prefix when handed a {@link SealTarget} — a cross-run writer that holds only
- * the recipient's public key.
+ * prefix when handed a {@link SealTarget}, a cross-run writer that holds
+ * only the recipient's public key.
  *
  * @param data - The format-prefixed serialized data
  * @param key - Encryption key (undefined to skip encryption)

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

@@ -4,14 +4,14 @@
  * All serialized payloads are prefixed with a 4-byte format identifier that
  * allows the deserializer to determine how to decode the payload. This enables:
  *
- * 1. Self-describing payloads — the World layer is agnostic to serialization format
- * 2. Gradual migration — old runs keep working, new runs can use new formats
- * 3. Composability — encryption can wrap any format ("encr" wrapping "devl")
- * 4. Debugging — raw data inspection immediately reveals the format
+ * 1. Self-describing payloads: the World layer is agnostic to serialization format
+ * 2. Gradual migration: old runs keep working, new runs can use new formats
+ * 3. Composability: encryption can wrap any format ("encr" wrapping "devl")
+ * 4. Debugging: raw data inspection immediately reveals the format
  *
  * Format: [4 bytes: format identifier][payload]
  *
- * The format prefix is open-ended — any 4-character [a-z0-9] string is valid.
+ * The format prefix is open-ended: any 4-character [a-z0-9] string is valid.
  * This allows new codecs to be added without modifying this module.
  */
 import { type FormatPrefix } from './types.js';
@@ -43,7 +43,7 @@ export declare function isEncrypted(data: Uint8Array | unknown): boolean;
  *
  * Unlike the legacy implementation which only accepted known formats
  * (`devl`, `encr`), this function accepts any valid format prefix
- * (`[a-z0-9]{4}`). This is intentional for forward compatibility —
+ * (`[a-z0-9]{4}`). This is intentional for forward compatibility, so
  * new codecs (e.g. `cbor`) can be added without modifying this module.
  * Callers are responsible for checking whether they support the returned
  * format and throwing an appropriate error if not (e.g. "Unsupported

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

@@ -3,7 +3,7 @@
  * workflow VM (`node:vm`) sandbox realm.
  *
  * Serialization runs on the host, but the values it inspects were
- * constructed by workflow code — so a naive dynamic operation like
+ * constructed by workflow code, so a naive dynamic operation like
  * `value.toISOString()`, `Array.from(map)`, or `Object.prototype.toString`
  * dispatches into the sandbox realm and executes workflow code (patched
  * prototype methods, getters, proxy traps, `Symbol.toStringTag` accessors).
@@ -15,26 +15,26 @@
  * it, and *observable* where it does not:
  *
  * - **Classification** uses engine-level brand checks (`node:util` `types`,
- *   internal-slot probes) instead of `instanceof` / `Object.prototype.toString`
- *   — immune to `Symbol.hasInstance`, `Symbol.toStringTag`, and reassigned
- *   globals.
+ *   internal-slot probes) instead of `instanceof` / `Object.prototype.toString`,
+ *   which makes it immune to `Symbol.hasInstance`, `Symbol.toStringTag`, and
+ *   reassigned globals.
  * - **Extraction** goes through intrinsics captured at module load (host
  *   boot, before any workflow code runs). Internal slots are realm-agnostic,
  *   so host intrinsics read VM-realm objects without touching the sandbox's
  *   (patchable) prototypes.
  * - **Property access** reads through descriptors, so plain data never
  *   invokes anything. Where workflow code *must* run because the data itself
- *   lives behind it — getters, proxies, custom `[WORKFLOW_SERIALIZE]`
- *   methods, `toString()` on toStringTag-branded objects (e.g. Temporal
- *   polyfills) — the execution is preserved for compatibility and recorded
+ *   lives behind it (getters, proxies, custom `[WORKFLOW_SERIALIZE]`
+ *   methods, `toString()` on toStringTag-branded objects such as Temporal
+ *   polyfills), the execution is preserved for compatibility and recorded
  *   in the active {@link GuestCodeStats} sink, so callers (e.g. a retained-VM
  *   gate) can react.
  *
  * **Recording is not prevention.** For the recorded cases the determinism
  * hazard is still live: a getter that calls `Math.random()` advances the
  * run's seeded PRNG during serialization, and because serialization happens
- * exactly once and is never replayed, every subsequent draw — including the
- * correlation ids derived from that stream — shifts relative to replay. The
+ * exactly once and is never replayed, every subsequent draw (including the
+ * correlation ids derived from that stream) shifts relative to replay. The
  * report is the only trace of that; acting on it (warning, demoting a
  * retained VM to replay) is left to the caller.
  *
@@ -54,8 +54,8 @@ export interface GuestCodeExecution {
      *   implies a **shape change**: brand checks answer "not that type" for a
      *   proxy, so a proxied `Map` serializes as a plain object rather than as a
      *   `Map`, and this report is the only evidence of it. (Such values were
-     *   never serializable before — the internal-slot reads in the previous
-     *   implementation threw on them — so the shape change replaces a crash,
+     *   never serializable before, since the internal-slot reads in the previous
+     *   implementation threw on them, so the shape change replaces a crash,
      *   but it is silent.)
      * - `method`: a workflow-defined function was invoked (e.g. a custom
      *   `[WORKFLOW_SERIALIZE]` serializer, `toString()` on a
@@ -67,14 +67,15 @@ export interface GuestCodeExecution {
     detail?: string;
 }
 /**
- * Mutable sink recording every workflow-code execution serialization could
- * not avoid. Pass via `CodecOptions.guestCodeStats`; consumers that retain
- * the VM across steps can use a non-empty `executions` array as a signal
- * that the VM state may have been perturbed by serialization.
+ * Mutable sink recording workflow-code execution serialization could not
+ * avoid. `executions` contains the first five samples and `totalExecutions`
+ * is the exact count.
  */
 export interface GuestCodeStats {
     executions: GuestCodeExecution[];
+    totalExecutions?: number;
 }
+export declare const GUEST_CODE_EXECUTION_SAMPLE_LIMIT = 5;
 /**
  * Runs `fn` (synchronously) with `stats` as the active guest-code sink.
  * Nested calls stack correctly; a `null`/`undefined` sink disables
@@ -114,35 +115,35 @@ export declare function hasProperty(value: unknown, key: PropertyKey): boolean;
  * `value instanceof C` semantics for a known `C.prototype`, without
  * consulting `Symbol.hasInstance` (which workflow code can define). Used
  * for host classes that are injected into the sandbox (Headers, URL,
- * URLSearchParams, DOMException), where the instances — from any realm the
- * host handed the class to — carry the host prototype in their chain.
+ * URLSearchParams, DOMException), where the instances (from any realm the
+ * host handed the class to) carry the host prototype in their chain.
  *
  * Proxies are walked rather than rejected: `Reflect.getPrototypeOf` fires
  * the proxy's `getPrototypeOf` trap, matching `instanceof` semantics, and
- * real values depend on that — Next.js hands the runtime a proxied
+ * real values depend on that: Next.js hands the runtime a proxied
  * `NextRequest`, and answering "not a Request" for it would silently break
  * webhooks. The traps are guest-observable, so the proxy is recorded.
  */
 export declare function isInstanceOfPrototype(value: unknown, prototype: object | undefined): boolean;
 /** `URL.prototype.href` getter. */
 export declare function urlHref(value: URL): string;
-/** `URLSearchParams.prototype.toString` — returns `''` iff empty. */
+/** `URLSearchParams.prototype.toString`: returns `''` iff empty. */
 export declare function urlSearchParamsToString(value: URLSearchParams): string;
 /**
  * Iterates a Headers instance through the captured host iterator, so the
- * iterator object — and its `next` — are host-realm.
+ * iterator object, and its `next`, are host-realm.
  */
 export declare function headersToEntries(value: Headers): [string, string][];
 /**
  * Iterates a genuine Map's entries entirely through host intrinsics: the
  * iterator object is created by the host `Map.prototype.entries`, so its
- * realm — and therefore its `next` — is the host's, not the sandbox's.
+ * realm, and therefore its `next`, is the host's, not the sandbox's.
  */
 export declare function mapToEntries(value: Map<unknown, unknown>): [unknown, unknown][];
 /** See {@link mapToEntries}. */
 export declare function setToValues(value: Set<unknown>): unknown[];
 /**
- * The bytes of an `ArrayBufferView`, read via internal-slot getters —
+ * The bytes of an `ArrayBufferView`, read via internal-slot getters, so
  * own-property shadowing and prototype patches cannot change which bytes
  * are serialized.
  */

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

@@ -1,5 +1,5 @@
 /**
- * Serialization module — public API.
+ * Serialization module: public API.
  *
  * Re-exports the mode-specific serialize/deserialize functions and
  * the codec/format/encryption abstractions.

package/dist/src/compiled/@workflow/core/serialization/reducers/class-vm.d.ts

@@ -1,7 +1,7 @@
 /**
  * VM-compatible copy: identical semantics to class.ts before the host-side
  * hardening (#3257) made that module depend on `serialization/hardened.ts`
- * (which imports `node:util` and captures host intrinsics — meaningless
+ * (which imports `node:util` and captures host intrinsics, meaningless
  * and unbundleable inside the QuickJS VM, where the codec already runs in
  * the guest realm). The host/guest boundary hardening for the QuickJS
  * engine lands with the host-side serde (#3263), which retires this

package/dist/src/compiled/@workflow/core/serialization/reducers/step-function-vm.d.ts

@@ -1,7 +1,7 @@
 /**
  * VM-compatible copy: identical semantics to step-function.ts before the host-side
  * hardening (#3257) made that module depend on `serialization/hardened.ts`
- * (which imports `node:util` and captures host intrinsics — meaningless
+ * (which imports `node:util` and captures host intrinsics, meaningless
  * and unbundleable inside the QuickJS VM, where the codec already runs in
  * the guest realm). The host/guest boundary hardening for the QuickJS
  * engine lands with the host-side serde (#3263), which retires this

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

@@ -5,7 +5,7 @@ import type { RuntimeDecryptionErrorContext } from '#compiled/@workflow/errors/i
 /**
  * A format prefix is exactly 4 lowercase alphanumeric characters [a-z0-9].
  *
- * This is a branded string type — use `isFormatPrefix()` to validate
+ * This is a branded string type: use `isFormatPrefix()` to validate
  * at runtime. The `SerializationFormat` object provides well-known
  * constants, but codecs may define additional prefixes.
  */
@@ -27,7 +27,7 @@ export declare const SerializationFormat: {
     /** Encrypted payload (inner payload has its own format prefix) */
     readonly ENCRYPTED: FormatPrefix;
     /**
-     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * Sealed payload: asymmetrically encrypted to a run's X25519 public key
      * (inner payload has its own format prefix).
      *
      * Used for *cross-run* writes (hook payloads, forwarded stream frames),
@@ -46,7 +46,7 @@ export declare const SerializationFormat: {
  * `ReadableStream` ref's `framing` field.
  *
  * - absent / `'raw'`: chunks are written to the transport verbatim
- *   (legacy format — no auto-reconnect support).
+ *   (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.
@@ -114,7 +114,7 @@ export interface SerializableSpecial {
          *
          * 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
+         * byte streams written by SDKs that predate framing support; those
          * are interpreted as `'raw'` by the consumer.
          */
         framing?: ByteStreamFraming;
@@ -244,7 +244,7 @@ export interface SerializableSpecial {
          * The owning run's X25519 public key (base64), when it has one.
          *
          * Lets the receiving run seal frames to the stream's owner with no
-         * lookup at all — neither a run fetch nor a key-API round trip. The
+         * lookup at all: neither a run fetch nor a key-API round trip. The
          * owner derives this locally when it creates the stream, so including
          * it here is free. Absent for runs created by older SDKs, in which
          * case the receiver falls back to resolving the owner's symmetric key.

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

@@ -9,7 +9,7 @@
  * node:util), which is also what made it bundleable into the VM before the
  * serde moved host-side.
  *
- * Produces and consumes the same wire format as the Node.js workflow.ts —
+ * Produces and consumes the same wire format as the Node.js workflow.ts:
  * format-prefixed devalue data ("devl" + devalue.stringify output).
  */
 /**

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

@@ -21,7 +21,7 @@ export declare const SerializationFormat: {
     /** Encrypted payload (inner payload has its own format prefix after decryption) */
     readonly ENCRYPTED: "encr";
     /**
-     * Sealed payload — asymmetrically encrypted to a run's X25519 public key
+     * Sealed payload: asymmetrically encrypted to a run's X25519 public key
      * (inner payload has its own format prefix after opening).
      *
      * Written by cross-run writers that hold only the recipient run's public
@@ -63,28 +63,28 @@ export declare const ENCRYPTED_PLACEHOLDER = "\uD83D\uDD12 Encrypted";
  */
 export declare function isExpiredStub(data: unknown): boolean;
 /**
- * Check if a binary value is ciphertext — either a symmetrically encrypted
+ * Check if a binary value is ciphertext: either a symmetrically encrypted
  * payload ('encr') or a sealed cross-run payload ('encp').
  *
  * This is the predicate display layers want: both schemes are opaque bytes
  * that must not be fed to the devalue parser, and both render as the same
  * "Encrypted" affordance in the CLI and web UI. Use {@link isSealedData} when
- * the *scheme* matters — notably when choosing a decryption path, since a
+ * the *scheme* matters, notably when choosing a decryption path, since a
  * sealed payload needs the run's private scalar rather than its symmetric key.
  *
- * Browser-safe — does not depend on the full serialization module.
+ * Browser-safe: does not depend on the full serialization module.
  */
 export declare function isEncryptedData(data: unknown): boolean;
 /**
  * Check if a binary value has the 'encp' format prefix, indicating a sealed
  * (asymmetrically encrypted) cross-run payload.
  *
- * Browser-safe — does not depend on the full serialization module.
+ * Browser-safe: does not depend on the full serialization module.
  */
 export declare function isSealedData(data: unknown): boolean;
 /**
  * Check if a binary value has a compression format prefix ('gzip' or 'zstd').
- * Browser-safe — does not depend on the full serialization module.
+ * Browser-safe: does not depend on the full serialization module.
  */
 export declare function isCompressedData(data: unknown): boolean;
 /**
@@ -109,7 +109,7 @@ export type Revivers = Record<string, (value: any) => any>;
  *
  * Encrypted data is intentionally left as a `Uint8Array` so that consumers
  * (CLI, web UI) can detect it with `isEncryptedData()` and decide how to
- * handle it — the CLI replaces it with a styled placeholder, the web UI
+ * handle it: the CLI replaces it with a styled placeholder, the web UI
  * renders an "Encrypted" card with a Decrypt button that triggers
  * client-side decryption on demand.
  */
@@ -126,8 +126,8 @@ export declare function hydrateData(value: unknown, revivers: Revivers): unknown
  * @param key - The run's key material. Pass `RunPayloadKeys` (from
  *   `deriveRunPayloadKeys`) to open both symmetric (`encr`) and sealed
  *   (`encp`) payloads; a bare `CryptoKey` opens only the symmetric ones.
- *   Typed as a read capability so a write-only seal target — which could open
- *   neither scheme — is rejected at compile time rather than failing here.
+ *   Typed as a read capability so a write-only seal target (which could open
+ *   neither scheme) is rejected at compile time rather than failing here.
  */
 export declare function hydrateDataWithKey(value: unknown, revivers: Revivers, key: import('./serialization/encryption.js').DecryptionKey | undefined): Promise<unknown>;
 /** Marker for stream reference objects rendered as links in the UI */
@@ -155,7 +155,7 @@ export declare const CLASS_INSTANCE_REF_TYPE = "__workflow_class_instance_ref__"
 /**
  * A class instance reference for o11y display.
  *
- * Browser-safe base class — no `util.inspect.custom`. Environment-specific
+ * Browser-safe base class: no `util.inspect.custom`. Environment-specific
  * rendering (CLI inspect, web component) is handled by each consumer.
  */
 export declare class ClassInstanceRef {
@@ -206,7 +206,7 @@ export declare const observabilityRevivers: Revivers;
  * Dispatches by resource type (step, hook, event, workflow) and calls
  * `hydrateData` with the provided revivers for each data field.
  *
- * Each environment (web, CLI) provides its own revivers — this function
+ * Each environment (web, CLI) provides its own revivers; this function
  * only handles the dispatch logic and field mapping.
  */
 export declare function hydrateResourceIO<T extends {