@workflow/core 5.0.0-beta.4 → 5.0.0-beta.40

package/dist/describe-error.js

@@ -0,0 +1,189 @@
+import { CorruptedEventLogError, RUN_ERROR_CODES, SerializationError, WorkflowRuntimeError, } from '@workflow/errors';
+import { classifyRunError } from './classify-error.js';
+import { NotInStepContextError, NotInWorkflowContextError, NotInWorkflowOrStepContextError, UnavailableInWorkflowContextError, } from './context-errors.js';
+const CONTEXT_ERROR_NAMES = new Set([
+    'NotInWorkflowContextError',
+    'NotInStepContextError',
+    'NotInWorkflowOrStepContextError',
+    'UnavailableInWorkflowContextError',
+]);
+function isContextViolationError(err) {
+    return (err instanceof NotInWorkflowContextError ||
+        err instanceof NotInStepContextError ||
+        err instanceof NotInWorkflowOrStepContextError ||
+        err instanceof UnavailableInWorkflowContextError);
+}
+const SERIALIZATION_ERROR_HINT = 'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';
+const CONTEXT_ERROR_HINT = 'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';
+const RUNTIME_ERROR_HINT = 'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';
+const CORRUPTED_EVENT_LOG_HINT = 'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';
+const REPLAY_TIMEOUT_HINT = 'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`"use step"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';
+const MAX_DELIVERIES_HINT = 'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';
+const MAX_EVENTS_HINT = 'The workflow exceeded the maximum number of events per run. This usually means unbounded work in the workflow function — e.g. a loop that keeps creating steps without terminating. Break long-running workflows into child workflows to stay under the limit.';
+const WORLD_CONTRACT_HINT = 'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';
+const DEPLOYMENT_MISMATCH_HINT = "The run was delivered to a deployment other than the deployment it is pinned to, and was stopped to protect against code-skew errors after the runtime failed to re-route it there. Verify that the run's deployment is still available and that queue callbacks route to it.";
+function normalizeErrorCode(code) {
+    // Values read back from persisted events are `string | undefined` — we
+    // only trust codes that match a known entry in `RUN_ERROR_CODES`.
+    const known = Object.values(RUN_ERROR_CODES);
+    if (code && known.includes(code)) {
+        return code;
+    }
+    return RUN_ERROR_CODES.USER_ERROR;
+}
+/**
+ * Data-driven variant of {@link describeError} that works from persisted
+ * event fields instead of a live `Error` instance. Intended for CLI/web
+ * renderers that read failure events and no longer have the original
+ * thrown object.
+ */
+export function describeRunError(signal) {
+    const name = signal.errorName;
+    const errorCode = name === 'CorruptedEventLogError'
+        ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG
+        : normalizeErrorCode(signal.errorCode);
+    if (name === 'SerializationError') {
+        return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };
+    }
+    if (name && CONTEXT_ERROR_NAMES.has(name)) {
+        return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };
+    }
+    if (name === 'CorruptedEventLogError') {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
+        return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
+        return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {
+        return { attribution: 'user', errorCode, hint: MAX_EVENTS_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode,
+            hint: WORLD_CONTRACT_HINT,
+        };
+    }
+    if (errorCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {
+        return { attribution: 'sdk', errorCode, hint: DEPLOYMENT_MISMATCH_HINT };
+    }
+    if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    }
+    if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {
+        return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };
+    }
+    return { attribution: 'user', errorCode };
+}
+/**
+ * Describe an error for user-facing presentation. Purely informational —
+ * does not change any persisted event data or error classification used by
+ * the runtime.
+ *
+ * The attribution here is more nuanced than `classifyRunError`:
+ *
+ * - `SerializationError` is technically raised by the SDK, but it almost
+ *   always points at something the caller did (passed a non-serializable
+ *   value, didn't register a class). We attribute it to the user.
+ * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise
+ *   describe a user mistake.
+ * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)
+ *   indicates an internal SDK invariant broke — surface that as `sdk`.
+ *
+ * @param err The error value thrown by the workflow / step.
+ * @param errorCode Optional precomputed error code. Callers that already
+ *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which
+ *   `classifyRunError` can't derive from the error alone) should pass it so
+ *   the attribution and hint reflect the actual failure category.
+ */
+export function describeError(err, errorCode) {
+    const effectiveCode = errorCode ?? classifyRunError(err);
+    if (SerializationError.is(err)) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: SERIALIZATION_ERROR_HINT,
+        };
+    }
+    if (isContextViolationError(err)) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: CONTEXT_ERROR_HINT,
+        };
+    }
+    if (CorruptedEventLogError.is(err)) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    // Check DEPLOYMENT_MISMATCH before the generic WorkflowRuntimeError branch —
+    // WorkflowDeploymentMismatchError subclasses it, but has its own code + hint.
+    if (effectiveCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: DEPLOYMENT_MISMATCH_HINT,
+        };
+    }
+    if (err instanceof WorkflowRuntimeError) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: RUNTIME_ERROR_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: REPLAY_TIMEOUT_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: MAX_DELIVERIES_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {
+        return {
+            attribution: 'user',
+            errorCode: effectiveCode,
+            hint: MAX_EVENTS_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: CORRUPTED_EVENT_LOG_HINT,
+        };
+    }
+    if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {
+        return {
+            attribution: 'sdk',
+            errorCode: effectiveCode,
+            hint: WORLD_CONTRACT_HINT,
+        };
+    }
+    return { attribution: 'user', errorCode: effectiveCode };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"describe-error.js","sourceRoot":"","sources":["../src/describe-error.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  CorruptedEventLogError,\n  RUN_ERROR_CODES,\n  type RunErrorCode,\n  SerializationError,\n  WorkflowRuntimeError,\n} from '@workflow/errors';\nimport { classifyRunError } from './classify-error.js';\nimport {\n  NotInStepContextError,\n  NotInWorkflowContextError,\n  NotInWorkflowOrStepContextError,\n  UnavailableInWorkflowContextError,\n} from './context-errors.js';\n\n/**\n * Attribution of a workflow/step failure for presentation.\n *\n * - `user`: the error came from customer code (a step or workflow function\n *   threw, or a value they passed across a boundary wasn't serializable).\n * - `sdk`: the SDK produced the error itself — an internal invariant broke,\n *   or a runtime guard rejected the call. These should be rare; when they\n *   happen we want to frame the terminal output as \"this is us, not you.\"\n */\nexport type ErrorAttribution = 'user' | 'sdk';\n\nexport interface ErrorDescription {\n  attribution: ErrorAttribution;\n  errorCode: RunErrorCode;\n  /**\n   * Short, class-aware hint to help a user understand what the error means.\n   * Only set for well-known SDK error classes (SerializationError,\n   * WorkflowRuntimeError, context-violation errors); `undefined` for plain\n   * user errors, where the stack is already the most useful thing to show.\n   */\n  hint?: string;\n}\n\n/**\n * Error signal fields carried on persisted failure events (e.g.\n * `run_failed` / `step_failed`). The shape is intentionally loose:\n *\n * - `errorCode` is typed as `string` rather than `RunErrorCode` because\n *   the value comes from stored JSON/CBOR and may predate the current\n *   enum — callers should not narrow on it blindly. Values that don't\n *   match a known `RUN_ERROR_CODES` entry fall through to USER_ERROR.\n * - `errorName` is the thrown `Error#name`. It is not universally\n *   persisted today; callers that have access to it (either via an\n *   in-memory throw or a richer payload) can pass it in to sharpen\n *   the attribution and hint. When absent, `describeRunError` still\n *   returns a sensible attribution from `errorCode` alone.\n */\nexport interface PersistedErrorSignal {\n  errorCode?: string;\n  errorName?: string;\n}\n\nconst CONTEXT_ERROR_NAMES = new Set([\n  'NotInWorkflowContextError',\n  'NotInStepContextError',\n  'NotInWorkflowOrStepContextError',\n  'UnavailableInWorkflowContextError',\n]);\n\nfunction isContextViolationError(err: unknown): boolean {\n  return (\n    err instanceof NotInWorkflowContextError ||\n    err instanceof NotInStepContextError ||\n    err instanceof NotInWorkflowOrStepContextError ||\n    err instanceof UnavailableInWorkflowContextError\n  );\n}\n\nconst SERIALIZATION_ERROR_HINT =\n  'A value passed across a workflow/step boundary could not be serialized. See the error message for the offending path and the Learn More link for details.';\nconst CONTEXT_ERROR_HINT =\n  'A workflow-only or step-only API was called from the wrong context. The error message includes the exact API and how to move the call.';\nconst RUNTIME_ERROR_HINT =\n  'This is an internal workflow SDK error, not a bug in your code. If it keeps happening, please report it with the stack trace and the runId.';\nconst CORRUPTED_EVENT_LOG_HINT =\n  'The workflow event log contains orphaned or mismatched events and cannot be replayed. This is an internal workflow SDK error; please report it with the runId.';\nconst REPLAY_TIMEOUT_HINT =\n  'The workflow replay between step boundaries took too long. This bounds workflow-VM and event-log replay time only — step bodies (`\"use step\"` functions) are excluded. This usually means the event log is unusually large or the workflow function is doing heavy synchronous work in workflow code outside of step bodies. Override the default budget via the WORKFLOW_REPLAY_TIMEOUT_MS env var if needed.';\nconst MAX_DELIVERIES_HINT =\n  'The workflow queue exceeded its max-delivery budget. This usually indicates a persistent runtime failure — check the most recent stack traces for the underlying cause.';\nconst MAX_EVENTS_HINT =\n  'The workflow exceeded the maximum number of events per run. This usually means unbounded work in the workflow function — e.g. a loop that keeps creating steps without terminating. Break long-running workflows into child workflows to stay under the limit.';\nconst WORLD_CONTRACT_HINT =\n  'The workflow backend returned data that violated the SDK contract. This is not retryable; please report it with the stack trace and runId.';\nconst DEPLOYMENT_MISMATCH_HINT =\n  \"The run was delivered to a deployment other than the deployment it is pinned to, and was stopped to protect against code-skew errors after the runtime failed to re-route it there. Verify that the run's deployment is still available and that queue callbacks route to it.\";\n\nfunction normalizeErrorCode(code: string | undefined): RunErrorCode {\n  // Values read back from persisted events are `string | undefined` — we\n  // only trust codes that match a known entry in `RUN_ERROR_CODES`.\n  const known = Object.values(RUN_ERROR_CODES) as readonly string[];\n  if (code && known.includes(code)) {\n    return code as RunErrorCode;\n  }\n  return RUN_ERROR_CODES.USER_ERROR;\n}\n\n/**\n * Data-driven variant of {@link describeError} that works from persisted\n * event fields instead of a live `Error` instance. Intended for CLI/web\n * renderers that read failure events and no longer have the original\n * thrown object.\n */\nexport function describeRunError(\n  signal: PersistedErrorSignal\n): ErrorDescription {\n  const name = signal.errorName;\n  const errorCode =\n    name === 'CorruptedEventLogError'\n      ? RUN_ERROR_CODES.CORRUPTED_EVENT_LOG\n      : normalizeErrorCode(signal.errorCode);\n\n  if (name === 'SerializationError') {\n    return { attribution: 'user', errorCode, hint: SERIALIZATION_ERROR_HINT };\n  }\n  if (name && CONTEXT_ERROR_NAMES.has(name)) {\n    return { attribution: 'user', errorCode, hint: CONTEXT_ERROR_HINT };\n  }\n  if (name === 'CorruptedEventLogError') {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return { attribution: 'sdk', errorCode, hint: REPLAY_TIMEOUT_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return { attribution: 'sdk', errorCode, hint: MAX_DELIVERIES_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {\n    return { attribution: 'user', errorCode, hint: MAX_EVENTS_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n  if (errorCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {\n    return { attribution: 'sdk', errorCode, hint: DEPLOYMENT_MISMATCH_HINT };\n  }\n  if (name === 'WorkflowRuntimeError' || name === 'StepNotRegisteredError') {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  if (errorCode === RUN_ERROR_CODES.RUNTIME_ERROR) {\n    return { attribution: 'sdk', errorCode, hint: RUNTIME_ERROR_HINT };\n  }\n  return { attribution: 'user', errorCode };\n}\n\n/**\n * Describe an error for user-facing presentation. Purely informational —\n * does not change any persisted event data or error classification used by\n * the runtime.\n *\n * The attribution here is more nuanced than `classifyRunError`:\n *\n * - `SerializationError` is technically raised by the SDK, but it almost\n *   always points at something the caller did (passed a non-serializable\n *   value, didn't register a class). We attribute it to the user.\n * - Context-violation errors (`NotInWorkflowContextError`, etc.) likewise\n *   describe a user mistake.\n * - `WorkflowRuntimeError` (and subclasses like `StepNotRegisteredError`)\n *   indicates an internal SDK invariant broke — surface that as `sdk`.\n *\n * @param err The error value thrown by the workflow / step.\n * @param errorCode Optional precomputed error code. Callers that already\n *   know the code (e.g. `REPLAY_TIMEOUT` or `MAX_DELIVERIES_EXCEEDED`, which\n *   `classifyRunError` can't derive from the error alone) should pass it so\n *   the attribution and hint reflect the actual failure category.\n */\nexport function describeError(\n  err: unknown,\n  errorCode?: RunErrorCode\n): ErrorDescription {\n  const effectiveCode = errorCode ?? classifyRunError(err);\n\n  if (SerializationError.is(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: SERIALIZATION_ERROR_HINT,\n    };\n  }\n\n  if (isContextViolationError(err)) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: CONTEXT_ERROR_HINT,\n    };\n  }\n\n  if (CorruptedEventLogError.is(err)) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  // Check DEPLOYMENT_MISMATCH before the generic WorkflowRuntimeError branch —\n  // WorkflowDeploymentMismatchError subclasses it, but has its own code + hint.\n  if (effectiveCode === RUN_ERROR_CODES.DEPLOYMENT_MISMATCH) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: DEPLOYMENT_MISMATCH_HINT,\n    };\n  }\n\n  if (err instanceof WorkflowRuntimeError) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: RUNTIME_ERROR_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.REPLAY_TIMEOUT) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: REPLAY_TIMEOUT_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.MAX_DELIVERIES_EXCEEDED) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: MAX_DELIVERIES_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.MAX_EVENTS_EXCEEDED) {\n    return {\n      attribution: 'user',\n      errorCode: effectiveCode,\n      hint: MAX_EVENTS_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.CORRUPTED_EVENT_LOG) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: CORRUPTED_EVENT_LOG_HINT,\n    };\n  }\n\n  if (effectiveCode === RUN_ERROR_CODES.WORLD_CONTRACT_ERROR) {\n    return {\n      attribution: 'sdk',\n      errorCode: effectiveCode,\n      hint: WORLD_CONTRACT_HINT,\n    };\n  }\n\n  return { attribution: 'user', errorCode: effectiveCode };\n}\n"]}

package/dist/encryption.d.ts

@@ -16,30 +16,64 @@
  * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
  */
 export type CryptoKey = import('node:crypto').webcrypto.CryptoKey;
+/** AES-GCM nonce length in bytes. */
+export declare const NONCE_LENGTH = 12;
+/** AES-GCM authentication tag length in bits. */
+export declare const TAG_LENGTH = 128;
+/** AES-GCM authentication tag length in bytes. */
+export declare const TAG_BYTES: number;
 /**
  * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.
  *
  * Callers should call this once per run (after `getEncryptionKeyForRun()`)
  * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
  *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
  * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
  * @returns CryptoKey ready for AES-GCM operations
  */
-export declare function importKey(raw: Uint8Array): Promise<import("crypto").webcrypto.CryptoKey>;
+export declare function importKey(raw: Uint8Array, usages?: ReadonlyArray<'encrypt' | 'decrypt'>): Promise<import("crypto").webcrypto.CryptoKey>;
 /**
  * Encrypt data using AES-256-GCM.
  *
  * @param key - CryptoKey from `importKey()`
  * @param data - Plaintext to encrypt
+ * @param aad - Optional additional authenticated data. Not encrypted, but
+ *   covered by the GCM auth tag: decryption fails unless the exact same
+ *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to
+ *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).
  * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  */
-export declare function encrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+export declare function encrypt(key: CryptoKey, data: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 /**
  * Decrypt data using AES-256-GCM.
  *
+ * Any failure inside the Web Crypto layer — most commonly an
+ * `OperationError: The operation failed for an operation-specific reason`
+ * raised by `AESCipherJob.onDone` when the GCM authentication tag does
+ * not verify — is rewrapped as {@link RuntimeDecryptionError}. The
+ * wrapped error carries the original DOMException as `cause`, plus a
+ * small diagnostic context (`operation`, input `byteLength`) to help
+ * disambiguate ciphertext corruption from key mismatch from truncated
+ * transport reads.
+ *
+ * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a
+ * format-prefixed envelope — callers strip the `encr` marker via
+ * `decodeFormatPrefix()` before reaching this function. The outer
+ * envelope's format prefix is therefore attached by the serialization
+ * layer (`serialization/encryption.ts`), which is the layer that has it.
+ *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ * @param aad - Optional additional authenticated data. Must match the bytes
+ *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify
+ *   and a {@link RuntimeDecryptionError} is thrown.
  * @returns Decrypted plaintext
  */
-export declare function decrypt(key: CryptoKey, data: Uint8Array): Promise<Uint8Array>;
+export declare function decrypt(key: CryptoKey, data: Uint8Array, aad?: Uint8Array): Promise<Uint8Array>;
 //# sourceMappingURL=encryption.d.ts.map

package/dist/encryption.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAMlE;;;;;;;;GAQG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,UAAU,iDAU9C;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAWrB;AAED;;;;;;GAMG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAerB"}
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,MAAM,SAAS,GAAG,OAAO,aAAa,EAAE,SAAS,CAAC,SAAS,CAAC;AAElE,qCAAqC;AACrC,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,iDAAiD;AACjD,eAAO,MAAM,UAAU,MAAM,CAAC;AAC9B,kDAAkD;AAClD,eAAO,MAAM,SAAS,QAAiB,CAAC;AAGxC;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,UAAU,EACf,MAAM,GAAE,aAAa,CAAC,SAAS,GAAG,SAAS,CAA0B,iDAiBtE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAiCrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,OAAO,CAC3B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,UAAU,EAChB,GAAG,CAAC,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CA+CrB"}

package/dist/encryption.js

@@ -1,22 +1,10 @@
-/**
- * Browser-compatible AES-256-GCM encryption module.
- *
- * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in
- * both modern browsers and Node.js 20+. This module is intentionally
- * free of Node.js-specific imports so it can be bundled for the browser.
- *
- * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte
- * AES-256 key. Callers should use `importKey()` once to convert it to a
- * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all
- * operations within the same run. This avoids repeated `importKey()`
- * calls on every encrypt/decrypt invocation.
- *
- * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`
- * The `encr` format prefix is NOT part of this module — it's added/stripped
- * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.
- */
-const NONCE_LENGTH = 12;
-const TAG_LENGTH = 128; // bits
+import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';
+/** AES-GCM nonce length in bytes. */
+export const NONCE_LENGTH = 12;
+/** AES-GCM authentication tag length in bits. */
+export const TAG_LENGTH = 128;
+/** AES-GCM authentication tag length in bytes. */
+export const TAG_BYTES = TAG_LENGTH / 8;
 const KEY_LENGTH = 32; // bytes (AES-256)
 /**
  * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.
@@ -24,28 +12,59 @@ const KEY_LENGTH = 32; // bytes (AES-256)
  * Callers should call this once per run (after `getEncryptionKeyForRun()`)
  * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.
  *
+ * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios
+ * where the caller should not be able to perform the inverse operation
+ * with the key — for example a child workflow writing into a parent
+ * run's forwarded WritableStream only needs to encrypt, never decrypt.
+ *
  * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)
+ * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.
  * @returns CryptoKey ready for AES-GCM operations
  */
-export async function importKey(raw) {
+export async function importKey(raw, usages = ['encrypt', 'decrypt']) {
     if (raw.byteLength !== KEY_LENGTH) {
-        throw new Error(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
+        throw new WorkflowRuntimeError(`Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`);
     }
-    return globalThis.crypto.subtle.importKey('raw', raw, 'AES-GCM', false, [
-        'encrypt',
-        'decrypt',
-    ]);
+    return globalThis.crypto.subtle.importKey('raw', raw, 'AES-GCM', false, 
+    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.
+    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches
+    // a strict subset of `KeyUsage[]`, so this cast is sound.
+    usages);
 }
 /**
  * Encrypt data using AES-256-GCM.
  *
  * @param key - CryptoKey from `importKey()`
  * @param data - Plaintext to encrypt
+ * @param aad - Optional additional authenticated data. Not encrypted, but
+ *   covered by the GCM auth tag: decryption fails unless the exact same
+ *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to
+ *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).
  * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`
  */
-export async function encrypt(key, data) {
+export async function encrypt(key, data, aad) {
     const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));
-    const ciphertext = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, data);
+    let ciphertext;
+    try {
+        ciphertext = await globalThis.crypto.subtle.encrypt({
+            name: 'AES-GCM',
+            iv: nonce,
+            tagLength: TAG_LENGTH,
+            ...(aad ? { additionalData: aad } : {}),
+        }, key, data);
+    }
+    catch (cause) {
+        // Re-wrap any Web Crypto failure (DOMException etc.) as a
+        // RuntimeDecryptionError. Failures here are rare — they happen e.g.
+        // when a CryptoKey was imported with `usages: ['decrypt']` only.
+        throw new RuntimeDecryptionError(`AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`, {
+            cause,
+            context: {
+                operation: 'encrypt',
+                byteLength: data.byteLength,
+            },
+        });
+    }
     const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);
     result.set(nonce, 0);
     result.set(new Uint8Array(ciphertext), NONCE_LENGTH);
@@ -54,18 +73,65 @@ export async function encrypt(key, data) {
 /**
  * Decrypt data using AES-256-GCM.
  *
+ * Any failure inside the Web Crypto layer — most commonly an
+ * `OperationError: The operation failed for an operation-specific reason`
+ * raised by `AESCipherJob.onDone` when the GCM authentication tag does
+ * not verify — is rewrapped as {@link RuntimeDecryptionError}. The
+ * wrapped error carries the original DOMException as `cause`, plus a
+ * small diagnostic context (`operation`, input `byteLength`) to help
+ * disambiguate ciphertext corruption from key mismatch from truncated
+ * transport reads.
+ *
+ * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a
+ * format-prefixed envelope — callers strip the `encr` marker via
+ * `decodeFormatPrefix()` before reaching this function. The outer
+ * envelope's format prefix is therefore attached by the serialization
+ * layer (`serialization/encryption.ts`), which is the layer that has it.
+ *
  * @param key - CryptoKey from `importKey()`
  * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`
+ * @param aad - Optional additional authenticated data. Must match the bytes
+ *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify
+ *   and a {@link RuntimeDecryptionError} is thrown.
  * @returns Decrypted plaintext
  */
-export async function decrypt(key, data) {
+export async function decrypt(key, data, aad) {
     const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag
     if (data.byteLength < minLength) {
-        throw new Error(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`);
+        throw new RuntimeDecryptionError(`Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`, {
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+            },
+        });
     }
     const nonce = data.subarray(0, NONCE_LENGTH);
     const ciphertext = data.subarray(NONCE_LENGTH);
-    const plaintext = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: nonce, tagLength: TAG_LENGTH }, key, ciphertext);
+    let plaintext;
+    try {
+        plaintext = await globalThis.crypto.subtle.decrypt({
+            name: 'AES-GCM',
+            iv: nonce,
+            tagLength: TAG_LENGTH,
+            ...(aad ? { additionalData: aad } : {}),
+        }, key, ciphertext);
+    }
+    catch (cause) {
+        // The most common shape we see in the wild is a DOMException with
+        // `name: 'OperationError'` and message "The operation failed for
+        // an operation-specific reason" — this is what Web Crypto throws
+        // when the GCM auth tag does not verify. Re-throw as
+        // RuntimeDecryptionError, attaching diagnostic context (byte length)
+        // that the bare DOMException lacks.
+        const causeMsg = cause instanceof Error ? cause.message : String(cause);
+        throw new RuntimeDecryptionError(`AES-256-GCM decryption failed: ${causeMsg}`, {
+            cause,
+            context: {
+                operation: 'decrypt',
+                byteLength: data.byteLength,
+            },
+        });
+    }
     return new Uint8Array(plaintext);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["import { RuntimeDecryptionError, WorkflowRuntimeError } from '@workflow/errors';\n\n/**\n * Browser-compatible AES-256-GCM encryption module.\n *\n * Uses the Web Crypto API (`globalThis.crypto.subtle`) which works in\n * both modern browsers and Node.js 20+. This module is intentionally\n * free of Node.js-specific imports so it can be bundled for the browser.\n *\n * The World interface (`getEncryptionKeyForRun`) returns a raw 32-byte\n * AES-256 key. Callers should use `importKey()` once to convert it to a\n * `CryptoKey`, then pass that to `encrypt()`/`decrypt()` for all\n * operations within the same run. This avoids repeated `importKey()`\n * calls on every encrypt/decrypt invocation.\n *\n * Wire format: `[nonce (12 bytes)][ciphertext + auth tag]`\n * The `encr` format prefix is NOT part of this module — it's added/stripped\n * by the serialization layer in `maybeEncrypt`/`maybeDecrypt`.\n */\n\n// CryptoKey is a global type in browsers and Node.js 20+, but TypeScript's\n// `es2022` lib doesn't include it. Re-export it from the node:crypto types\n// so consumers can reference it without adding `dom` lib.\nexport type CryptoKey = import('node:crypto').webcrypto.CryptoKey;\n\n/** AES-GCM nonce length in bytes. */\nexport const NONCE_LENGTH = 12;\n/** AES-GCM authentication tag length in bits. */\nexport const TAG_LENGTH = 128;\n/** AES-GCM authentication tag length in bytes. */\nexport const TAG_BYTES = TAG_LENGTH / 8;\nconst KEY_LENGTH = 32; // bytes (AES-256)\n\n/**\n * Import a raw AES-256 key as a `CryptoKey` for use with `encrypt()`/`decrypt()`.\n *\n * Callers should call this once per run (after `getEncryptionKeyForRun()`)\n * and pass the resulting `CryptoKey` to all subsequent encrypt/decrypt calls.\n *\n * Pass `usages: ['encrypt']` (or `['decrypt']`) for cross-run scenarios\n * where the caller should not be able to perform the inverse operation\n * with the key — for example a child workflow writing into a parent\n * run's forwarded WritableStream only needs to encrypt, never decrypt.\n *\n * @param raw - Raw 32-byte AES-256 key (from World.getEncryptionKeyForRun)\n * @param usages - Key usages. Defaults to `['encrypt', 'decrypt']`.\n * @returns CryptoKey ready for AES-GCM operations\n */\nexport async function importKey(\n  raw: Uint8Array,\n  usages: ReadonlyArray<'encrypt' | 'decrypt'> = ['encrypt', 'decrypt']\n) {\n  if (raw.byteLength !== KEY_LENGTH) {\n    throw new WorkflowRuntimeError(\n      `Encryption key must be exactly ${KEY_LENGTH} bytes, got ${raw.byteLength}`\n    );\n  }\n  return globalThis.crypto.subtle.importKey(\n    'raw',\n    raw,\n    'AES-GCM',\n    false,\n    // `KeyUsage` is a DOM-lib type that's not in scope under `es2022`.\n    // The `ReadonlyArray<'encrypt' | 'decrypt'>` parameter type matches\n    // a strict subset of `KeyUsage[]`, so this cast is sound.\n    usages as ('encrypt' | 'decrypt')[]\n  );\n}\n\n/**\n * Encrypt data using AES-256-GCM.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - Plaintext to encrypt\n * @param aad - Optional additional authenticated data. Not encrypted, but\n *   covered by the GCM auth tag: decryption fails unless the exact same\n *   bytes are supplied. Used by the sealed-box layer to bind ciphertext to\n *   a `projectId|runId` context. Omit for no AAD (the legacy behavior).\n * @returns `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n */\nexport async function encrypt(\n  key: CryptoKey,\n  data: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  const nonce = globalThis.crypto.getRandomValues(new Uint8Array(NONCE_LENGTH));\n  let ciphertext: ArrayBuffer;\n  try {\n    ciphertext = await globalThis.crypto.subtle.encrypt(\n      {\n        name: 'AES-GCM',\n        iv: nonce,\n        tagLength: TAG_LENGTH,\n        ...(aad ? { additionalData: aad } : {}),\n      },\n      key,\n      data\n    );\n  } catch (cause) {\n    // Re-wrap any Web Crypto failure (DOMException etc.) as a\n    // RuntimeDecryptionError. Failures here are rare — they happen e.g.\n    // when a CryptoKey was imported with `usages: ['decrypt']` only.\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM encryption failed: ${cause instanceof Error ? cause.message : String(cause)}`,\n      {\n        cause,\n        context: {\n          operation: 'encrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const result = new Uint8Array(NONCE_LENGTH + ciphertext.byteLength);\n  result.set(nonce, 0);\n  result.set(new Uint8Array(ciphertext), NONCE_LENGTH);\n  return result;\n}\n\n/**\n * Decrypt data using AES-256-GCM.\n *\n * Any failure inside the Web Crypto layer — most commonly an\n * `OperationError: The operation failed for an operation-specific reason`\n * raised by `AESCipherJob.onDone` when the GCM authentication tag does\n * not verify — is rewrapped as {@link RuntimeDecryptionError}. The\n * wrapped error carries the original DOMException as `cause`, plus a\n * small diagnostic context (`operation`, input `byteLength`) to help\n * disambiguate ciphertext corruption from key mismatch from truncated\n * transport reads.\n *\n * Note: `data` is the raw AES payload (`[nonce][ciphertext + tag]`), not a\n * format-prefixed envelope — callers strip the `encr` marker via\n * `decodeFormatPrefix()` before reaching this function. The outer\n * envelope's format prefix is therefore attached by the serialization\n * layer (`serialization/encryption.ts`), which is the layer that has it.\n *\n * @param key - CryptoKey from `importKey()`\n * @param data - `[nonce (12 bytes)][ciphertext + GCM auth tag]`\n * @param aad - Optional additional authenticated data. Must match the bytes\n *   passed to {@link encrypt} exactly, otherwise the GCM tag fails to verify\n *   and a {@link RuntimeDecryptionError} is thrown.\n * @returns Decrypted plaintext\n */\nexport async function decrypt(\n  key: CryptoKey,\n  data: Uint8Array,\n  aad?: Uint8Array\n): Promise<Uint8Array> {\n  const minLength = NONCE_LENGTH + TAG_LENGTH / 8; // nonce + auth tag\n  if (data.byteLength < minLength) {\n    throw new RuntimeDecryptionError(\n      `Encrypted data too short: expected at least ${minLength} bytes, got ${data.byteLength}`,\n      {\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  const nonce = data.subarray(0, NONCE_LENGTH);\n  const ciphertext = data.subarray(NONCE_LENGTH);\n  let plaintext: ArrayBuffer;\n  try {\n    plaintext = await globalThis.crypto.subtle.decrypt(\n      {\n        name: 'AES-GCM',\n        iv: nonce,\n        tagLength: TAG_LENGTH,\n        ...(aad ? { additionalData: aad } : {}),\n      },\n      key,\n      ciphertext\n    );\n  } catch (cause) {\n    // The most common shape we see in the wild is a DOMException with\n    // `name: 'OperationError'` and message \"The operation failed for\n    // an operation-specific reason\" — this is what Web Crypto throws\n    // when the GCM auth tag does not verify. Re-throw as\n    // RuntimeDecryptionError, attaching diagnostic context (byte length)\n    // that the bare DOMException lacks.\n    const causeMsg = cause instanceof Error ? cause.message : String(cause);\n    throw new RuntimeDecryptionError(\n      `AES-256-GCM decryption failed: ${causeMsg}`,\n      {\n        cause,\n        context: {\n          operation: 'decrypt',\n          byteLength: data.byteLength,\n        },\n      }\n    );\n  }\n  return new Uint8Array(plaintext);\n}\n"]}

package/dist/events-consumer.d.ts

@@ -1,4 +1,11 @@
-import type { Event } from '@workflow/world';
+import { type Event } from '@workflow/world';
+/**
+ * Delay before firing the deferred unconsumed-event check after the promise
+ * queue has drained. Must be long enough for cross-VM microtask chains to
+ * propagate (resolve in host → workflow code in VM → subscribe call back
+ * in host). Any subscribe() arriving during this window cancels the check.
+ */
+export declare const DEFERRED_CHECK_DELAY_MS = 100;
 export declare enum EventConsumerResult {
     /**
      * Callback consumed the event, but should not be removed from the callbacks list
@@ -15,6 +22,12 @@ export declare enum EventConsumerResult {
 }
 type EventConsumerCallback = (event: Event | null) => EventConsumerResult;
 export interface EventsConsumerOptions {
+    /**
+     * Callback invoked after an event has been consumed. Consumers such as the
+     * deterministic workflow clock must not observe events that are merely
+     * inspected while waiting for user code to subscribe to the next operation.
+     */
+    onConsumedEvent?: (event: Event) => void;
     /**
      * Callback invoked when a non-null event cannot be consumed by any registered
      * callback, indicating an orphaned or invalid event in the event log. The
@@ -35,12 +48,14 @@ export declare class EventsConsumer {
     eventIndex: number;
     readonly events: Event[];
     readonly callbacks: EventConsumerCallback[];
+    private onConsumedEvent?;
     private onUnconsumedEvent;
     private getPromiseQueue;
     private pendingUnconsumedCheck;
     private pendingUnconsumedTimeout;
     private unconsumedCheckVersion;
     constructor(events: Event[], options: EventsConsumerOptions);
+    append(events: Event[]): void;
     /**
      * Registers a callback function to be called after an event has been consumed
      * by a different callback. The callback can return:
@@ -51,7 +66,17 @@ export declare class EventsConsumer {
      * @param fn - The callback function to register.
      */
     subscribe(fn: EventConsumerCallback): void;
+    private notifyConsumedEvent;
     private consume;
+    /**
+     * Offer `currentEvent` to each registered callback in turn. Returns true
+     * when a callback consumed a real (non-null) event and the drain should
+     * advance to the next event in the same synchronous pass; false otherwise
+     * (nothing consumed it, or the consumed event was the end-of-events
+     * sentinel).
+     */
+    private consumeOne;
+    private handleUnconsumed;
 }
 export {};
 //# sourceMappingURL=events-consumer.d.ts.map

package/dist/events-consumer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAG7C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAM;IAC9B,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAO3D;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,OAAO,CA+Db;CACH"}
+{"version":3,"file":"events-consumer.d.ts","sourceRoot":"","sources":["../src/events-consumer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAa,MAAM,iBAAiB,CAAC;AAGxD;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,MAAM,CAAC;AAmB3C,oBAAY,mBAAmB;IAC7B;;OAEG;IACH,QAAQ,IAAA;IACR;;OAEG;IACH,WAAW,IAAA;IACX;;OAEG;IACH,QAAQ,IAAA;CACT;AAED,KAAK,qBAAqB,GAAG,CAAC,KAAK,EAAE,KAAK,GAAG,IAAI,KAAK,mBAAmB,CAAC;AAE1E,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,eAAe,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IACzC;;;;;;OAMG;IACH,iBAAiB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;IAC1C;;;;;OAKG;IACH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC;AAED,qBAAa,cAAc;IACzB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,qBAAqB,EAAE,CAAM;IACjD,OAAO,CAAC,eAAe,CAAC,CAAyB;IACjD,OAAO,CAAC,iBAAiB,CAAyB;IAClD,OAAO,CAAC,eAAe,CAAsB;IAC7C,OAAO,CAAC,sBAAsB,CAA8B;IAC5D,OAAO,CAAC,wBAAwB,CAA8C;IAC9E,OAAO,CAAC,sBAAsB,CAAK;gBAEvB,MAAM,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,qBAAqB;IAW3D,MAAM,CAAC,MAAM,EAAE,KAAK,EAAE,GAAG,IAAI;IAK7B;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,EAAE,qBAAqB;IAgBnC,OAAO,CAAC,mBAAmB;IAa3B,OAAO,CAAC,OAAO,CA0Bb;IAEF;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAgClB,OAAO,CAAC,gBAAgB;CAqCzB"}