@workflow/cli 5.0.0-beta.4 → 5.0.0-beta.41

package/dist/lib/inspect/errors.js

@@ -0,0 +1,27 @@
+const OBSERVABILITY_UPGRADE_REQUIRED_CODE = 'observability-upgrade-required';
+const OBSERVABILITY_UPGRADE_REQUIRED_MESSAGE = 'This workflow observability data is outside your current plan window. Upgrade Observability Plus to view up to 30 days of workflow data.';
+const extractErrorCode = (err) => {
+    if (err.code && typeof err.code === 'string') {
+        return err.code;
+    }
+    if (err.body && typeof err.body === 'object') {
+        const body = err.body;
+        if (body.code && typeof body.code === 'string') {
+            return body.code;
+        }
+        if (body.error && typeof body.error === 'string') {
+            return body.error;
+        }
+    }
+    return undefined;
+};
+export const isObservabilityUpgradeRequiredError = (error) => {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const err = error;
+    return (err.status === 402 &&
+        extractErrorCode(err) === OBSERVABILITY_UPGRADE_REQUIRED_CODE);
+};
+export const getObservabilityUpgradeRequiredMessage = () => OBSERVABILITY_UPGRADE_REQUIRED_MESSAGE;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/inspect/flags.d.ts

@@ -11,8 +11,17 @@ export declare const cliFlags: {
     webPort: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     noBrowser: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     localUi: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    standalone: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     sort: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
     limit: import("@oclif/core/interfaces").OptionFlag<number, import("@oclif/core/interfaces").CustomOptions>;
     interactive: import("@oclif/core/interfaces").BooleanFlag<boolean>;
 };
+/**
+ * Flag for printing a shareable deep-link URL instead of opening the web UI.
+ * Only relevant to commands that can open a dashboard (`inspect`, `web`), so it
+ * is exported separately rather than bundled into `cliFlags`.
+ */
+export declare const urlFlag: {
+    url: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+};
 //# sourceMappingURL=flags.d.ts.map

package/dist/lib/inspect/flags.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;CAgJpB,CAAC"}
+{"version":3,"file":"flags.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;CAyJpB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO;;CASnB,CAAC"}

package/dist/lib/inspect/flags.js

@@ -113,6 +113,14 @@ export const cliFlags = {
         helpGroup: 'Output',
         helpLabel: '--localUi',
     }),
+    standalone: Flags.boolean({
+        description: 'Always start the standalone web UI, even if an embedded dashboard (e.g. /_workflow) is already running',
+        required: false,
+        default: false,
+        env: 'WORKFLOW_STANDALONE_UI',
+        helpGroup: 'Output',
+        helpLabel: '--standalone',
+    }),
     sort: Flags.string({
         description: 'sort order for list commands',
         required: false,
@@ -140,4 +148,18 @@ export const cliFlags = {
         helpLabel: '-i, --interactive',
     }),
 };
-//# sourceMappingURL=flags.js.map
+/**
+ * Flag for printing a shareable deep-link URL instead of opening the web UI.
+ * Only relevant to commands that can open a dashboard (`inspect`, `web`), so it
+ * is exported separately rather than bundled into `cliFlags`.
+ */
+export const urlFlag = {
+    url: Flags.boolean({
+        description: 'Print the deep-link URL to the run/dashboard and exit (no browser, no server)',
+        required: false,
+        default: false,
+        helpGroup: 'Output',
+        helpLabel: '--url',
+    }),
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"flags.js","sourceRoot":"","sources":["../../../src/lib/inspect/flags.ts"],"names":[],"mappings":"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","sourcesContent":["import { Flags } from '@oclif/core';\n\nexport const cliFlags = {\n  verbose: Flags.boolean({\n    description: 'Verbose output',\n    required: false,\n    char: 'v',\n    helpGroup: 'Output',\n    helpLabel: '-v, --verbose',\n    env: 'DEBUG',\n    default: false,\n  }),\n  json: Flags.boolean({\n    description: 'output JSON instead of human-readable tables/streams',\n    required: false,\n    char: 'j',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-j, --json',\n  }),\n  cursor: Flags.string({\n    description: 'pagination cursor for list commands',\n    required: false,\n    default: '',\n    helpGroup: 'Filtering',\n    helpLabel: '--cursor',\n    helpValue: 'CURSOR',\n  }),\n  backend: Flags.string({\n    description: 'backend to inspect',\n    required: false,\n    char: 'b',\n    default: 'local',\n    env: 'WORKFLOW_TARGET_WORLD',\n    helpGroup: 'Target',\n    helpLabel: '-b, --backend',\n    helpValue: ['local', 'vercel', '<your-package-name>'],\n    defaultHelp: 'local',\n  }),\n  authToken: Flags.string({\n    description:\n      'Authentication token to be passed to the backend. If not provided and the backend is vercel, will fall back to the token generated by `vc login`.',\n    required: false,\n    char: 'a',\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_AUTH_TOKEN',\n    helpGroup: 'Target',\n    helpLabel: '-a, --authToken',\n    helpValue: 'TOKEN',\n  }),\n  project: Flags.string({\n    description:\n      'If backend is vercel, the vercel project to authenticate against',\n    required: false,\n    default: '',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_PROJECT',\n    helpGroup: 'Target',\n    helpLabel: '--project',\n    helpValue: 'PROJECT',\n  }),\n  team: Flags.string({\n    description:\n      'If backend is vercel, the vercel team to authenticate against',\n    required: false,\n    dependsOn: ['backend'],\n    default: '',\n    env: 'WORKFLOW_VERCEL_TEAM',\n    helpGroup: 'Target',\n    helpLabel: '--team',\n    helpValue: 'TEAM',\n  }),\n  env: Flags.string({\n    description: 'If backend is vercel, the vercel environment to use',\n    required: false,\n    options: ['production', 'preview'],\n    default: 'production',\n    char: 'e',\n    dependsOn: ['backend'],\n    env: 'WORKFLOW_VERCEL_ENV',\n    helpGroup: 'Target',\n    helpLabel: '-e, --env',\n    helpValue: ['production', 'preview'],\n    defaultHelp: 'production',\n  }),\n  web: Flags.boolean({\n    description: 'Open the web UI instead of displaying in terminal',\n    required: false,\n    char: 'w',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-w, --web',\n  }),\n  webPort: Flags.integer({\n    description: 'Port to use when launching the web UI (default: 3456)',\n    required: false,\n    default: 3456,\n    helpGroup: 'Output',\n    helpLabel: '--webPort',\n    helpValue: 'WEB_PORT',\n    env: 'WORKFLOW_WEB_PORT',\n  }),\n  noBrowser: Flags.boolean({\n    description: 'Disable automatic browser opening when launching web UI',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_DISABLE_BROWSER_OPEN',\n    helpGroup: 'Output',\n    helpLabel: '--noBrowser',\n  }),\n  localUi: Flags.boolean({\n    description:\n      'Use local web UI instead of Vercel dashboard (when backend is vercel)',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_LOCAL_UI',\n    helpGroup: 'Output',\n    helpLabel: '--localUi',\n  }),\n  standalone: Flags.boolean({\n    description:\n      'Always start the standalone web UI, even if an embedded dashboard (e.g. /_workflow) is already running',\n    required: false,\n    default: false,\n    env: 'WORKFLOW_STANDALONE_UI',\n    helpGroup: 'Output',\n    helpLabel: '--standalone',\n  }),\n  sort: Flags.string({\n    description: 'sort order for list commands',\n    required: false,\n    options: ['asc', 'desc'],\n    default: 'desc',\n    helpGroup: 'Filtering',\n    helpLabel: '--sort',\n    helpValue: ['asc', 'desc'],\n    defaultHelp: 'desc',\n  }),\n  limit: Flags.integer({\n    description: 'number of items to return per page',\n    required: false,\n    default: 20,\n    helpGroup: 'Filtering',\n    helpLabel: '--limit',\n    helpValue: 'NUMBER',\n  }),\n  interactive: Flags.boolean({\n    description: 'Enable interactive pagination with keyboard controls',\n    required: false,\n    char: 'i',\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '-i, --interactive',\n  }),\n};\n\n/**\n * Flag for printing a shareable deep-link URL instead of opening the web UI.\n * Only relevant to commands that can open a dashboard (`inspect`, `web`), so it\n * is exported separately rather than bundled into `cliFlags`.\n */\nexport const urlFlag = {\n  url: Flags.boolean({\n    description:\n      'Print the deep-link URL to the run/dashboard and exit (no browser, no server)',\n    required: false,\n    default: false,\n    helpGroup: 'Output',\n    helpLabel: '--url',\n  }),\n};\n"]}

package/dist/lib/inspect/hydration.d.ts

@@ -41,6 +41,28 @@ declare class ExpiredDataRef {
 }
 /** Check if a value is an ExpiredDataRef (for custom table formatting in CLI) */
 export declare function isExpiredRef(value: unknown): value is ExpiredDataRef;
+/**
+ * The set of revivers used by CLI inspect output.
+ *
+ * Built on top of `getCommonRevivers()` from `@workflow/core` so that the
+ * CLI stays in sync with the runtime's reviver set automatically. Without
+ * this, every new reviver added to core (e.g. `FatalError`,
+ * `RetryableError`, the built-in `Error` subclasses) would silently
+ * disappear from CLI output: devalue throws "Unknown type X" for
+ * unrecognized reduced types, and `hydrateResourceIO` swallows that error
+ * and surfaces the raw `Uint8Array` payload to consumers — which then
+ * shows up as `step.error` / `run.error` byte dumps instead of usable
+ * `{ message, stack, … }` objects.
+ *
+ * On top of the common set we layer:
+ *   - A `toJSON` shim on each Error reviver so non-enumerable
+ *     `Error.prototype` fields survive `JSON.stringify` for `--json` output
+ *     while leaving `util.inspect` rendering untouched
+ *   - `observabilityRevivers` for streams / step+workflow function refs
+ *   - CLI-specific overrides that produce display-friendly placeholders
+ *     for `Class` / `Instance` (the runtime versions need full class
+ *     identity which the CLI doesn't have access to)
+ */
 export declare function getCLIRevivers(): Revivers;
 /**
  * Hydrate the serialized data fields of a resource for CLI display.

package/dist/lib/inspect/hydration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAQL,KAAK,QAAQ,EAEd,MAAM,qCAAqC,CAAC;AAI7C;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,GACpD,IAAI,CAAC;AAGT,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,KAAK,QAAQ,EACb,eAAe,EACf,KAAK,SAAS,EACd,UAAU,GACX,MAAM,qCAAqC,CAAC;AA8B7C;;;;;;GAMG;AACH,cAAM,gBAAgB;IACpB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAExE;AAMD;;;;;;GAMG;AACH,cAAM,cAAc;IAClB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAEpE;AAMD,wBAAgB,cAAc,IAAI,QAAQ,CAyFzC;AA8HD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,EACX,WAAW,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,CAAC,CASZ"}
+{"version":3,"file":"hydration.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAQL,KAAK,QAAQ,EAEd,MAAM,qCAAqC,CAAC;AAK7C;;;;GAIG;AACH,MAAM,MAAM,qBAAqB,GAC7B,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,UAAU,GAAG,SAAS,CAAC,CAAC,GACpD,IAAI,CAAC;AAGT,OAAO,EACL,uBAAuB,EACvB,gBAAgB,EAChB,qBAAqB,EACrB,gBAAgB,EAChB,kBAAkB,EAClB,eAAe,EACf,UAAU,EACV,WAAW,EACX,KAAK,QAAQ,EACb,eAAe,EACf,KAAK,SAAS,EACd,UAAU,GACX,MAAM,qCAAqC,CAAC;AA8B7C;;;;;;GAMG;AACH,cAAM,gBAAgB;IACpB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,mFAAmF;AACnF,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,gBAAgB,CAExE;AAMD;;;;;;GAMG;AACH,cAAM,cAAc;IAClB,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;IAI1B,MAAM,IAAI,MAAM;IAIhB,QAAQ,IAAI,MAAM;CAGnB;AAKD,iFAAiF;AACjF,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,cAAc,CAEpE;AAwED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,IAAI,QAAQ,CA6DzC;AAgID;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,CAAC,CAAC,EACvC,QAAQ,EAAE,CAAC,EACX,WAAW,CAAC,EAAE,qBAAqB,GAClC,OAAO,CAAC,CAAC,CAAC,CASZ"}

package/dist/lib/inspect/hydration.js

@@ -5,9 +5,10 @@
  * `util.inspect.custom` to ClassInstanceRef for pretty CLI output.
  */
 import { inspect } from 'node:util';
-import { maybeDecrypt } from '@workflow/core/serialization';
+import { getCommonRevivers, maybeDecrypt } from '@workflow/core/serialization';
 import { ClassInstanceRef, extractClassName, hydrateResourceIO as hydrateResourceIOGeneric, isEncryptedData, isExpiredStub, isRunRef, observabilityRevivers, serializedInstanceToRef, } from '@workflow/core/serialization-format';
 import { parseClassName } from '@workflow/utils/parse-name';
+import { getEventDataRefFields } from '@workflow/world';
 import chalk from 'chalk';
 // Re-export types and utilities that consumers need
 export { CLASS_INSTANCE_REF_TYPE, ClassInstanceRef, ENCRYPTED_PLACEHOLDER, extractStreamIds, isClassInstanceRef, isEncryptedData, isStreamId, isStreamRef, STREAM_REF_TYPE, truncateId, } from '@workflow/core/serialization-format';
@@ -87,30 +88,104 @@ export function isExpiredRef(value) {
 // ---------------------------------------------------------------------------
 // CLI revivers (Node.js, uses Buffer)
 // ---------------------------------------------------------------------------
+/**
+ * The set of reducer keys whose `getCommonRevivers()` output produces a
+ * native `Error` instance. We wrap each of these with an additional
+ * `toJSON` attachment in CLI mode (see `wrapErrorReviverWithToJSON`).
+ */
+const ERROR_REVIVER_KEYS = [
+    'AggregateError',
+    'DOMException',
+    'Error',
+    'EvalError',
+    'FatalError',
+    'HookConflictError',
+    'RangeError',
+    'ReferenceError',
+    'RetryableError',
+    'RuntimeDecryptionError',
+    'SyntaxError',
+    'TypeError',
+    'URIError',
+];
+/**
+ * Wraps a runtime Error reviver so that the produced instance carries a
+ * non-enumerable `toJSON` method. The runtime revivers return real `Error`
+ * instances (good for `util.inspect`, `instanceof`, `toString`, etc.), but
+ * `Error.prototype`'s `name` / `message` / `stack` / `cause` are
+ * non-enumerable and would be dropped by `JSON.stringify` — which is how
+ * the CLI emits its `--json` output. Adding `toJSON` (which `JSON.stringify`
+ * calls but `util.inspect` ignores) gives us the best of both worlds:
+ * round-tripped errors render cleanly in both modes without the
+ * data-versus-display tradeoff that plain-object revivers would force.
+ *
+ * Subclass-specific enumerable fields (e.g. `RetryableError.retryAfter`,
+ * `AggregateError.errors`, `FatalError.fatal`) are picked up automatically
+ * via `Object.assign` after the base fields, so we don't have to enumerate
+ * them per-subclass.
+ */
+function wrapErrorReviverWithToJSON(reviver) {
+    return (value) => {
+        const result = reviver(value);
+        if (!(result instanceof Error))
+            return result;
+        Object.defineProperty(result, 'toJSON', {
+            value: function () {
+                const json = {
+                    name: this.name,
+                    message: this.message,
+                    stack: this.stack,
+                };
+                if ('cause' in this) {
+                    json.cause = this.cause;
+                }
+                // Pick up subclass-specific enumerable fields (e.g. FatalError.fatal,
+                // RetryableError.retryAfter, AggregateError.errors).
+                Object.assign(json, this);
+                return json;
+            },
+            enumerable: false,
+            writable: true,
+            configurable: true,
+        });
+        return result;
+    };
+}
+/**
+ * The set of revivers used by CLI inspect output.
+ *
+ * Built on top of `getCommonRevivers()` from `@workflow/core` so that the
+ * CLI stays in sync with the runtime's reviver set automatically. Without
+ * this, every new reviver added to core (e.g. `FatalError`,
+ * `RetryableError`, the built-in `Error` subclasses) would silently
+ * disappear from CLI output: devalue throws "Unknown type X" for
+ * unrecognized reduced types, and `hydrateResourceIO` swallows that error
+ * and surfaces the raw `Uint8Array` payload to consumers — which then
+ * shows up as `step.error` / `run.error` byte dumps instead of usable
+ * `{ message, stack, … }` objects.
+ *
+ * On top of the common set we layer:
+ *   - A `toJSON` shim on each Error reviver so non-enumerable
+ *     `Error.prototype` fields survive `JSON.stringify` for `--json` output
+ *     while leaving `util.inspect` rendering untouched
+ *   - `observabilityRevivers` for streams / step+workflow function refs
+ *   - CLI-specific overrides that produce display-friendly placeholders
+ *     for `Class` / `Instance` (the runtime versions need full class
+ *     identity which the CLI doesn't have access to)
+ */
 export function getCLIRevivers() {
-    function reviveArrayBuffer(value) {
-        const base64 = value === '.' ? '' : value;
-        const buffer = Buffer.from(base64, 'base64');
-        const arrayBuffer = new ArrayBuffer(buffer.length);
-        const uint8Array = new Uint8Array(arrayBuffer);
-        uint8Array.set(buffer);
-        return arrayBuffer;
-    }
+    const baseRevivers = getCommonRevivers(globalThis);
+    const errorRevivers = Object.fromEntries(ERROR_REVIVER_KEYS.flatMap((key) => {
+        const reviver = baseRevivers[key];
+        return reviver ? [[key, wrapErrorReviverWithToJSON(reviver)]] : [];
+    }));
     return {
-        ArrayBuffer: reviveArrayBuffer,
-        BigInt: (value) => BigInt(value),
-        BigInt64Array: (value) => new BigInt64Array(reviveArrayBuffer(value)),
-        BigUint64Array: (value) => new BigUint64Array(reviveArrayBuffer(value)),
-        Date: (value) => new Date(value),
-        Error: (value) => {
-            const error = new Error(value.message);
-            error.name = value.name;
-            error.stack = value.stack;
-            return error;
-        },
-        Float32Array: (value) => new Float32Array(reviveArrayBuffer(value)),
-        Float64Array: (value) => new Float64Array(reviveArrayBuffer(value)),
-        Headers: (value) => new Headers(value),
+        ...baseRevivers,
+        ...errorRevivers,
+        // O11y-specific revivers (streams, step functions → display objects).
+        ...observabilityRevivers,
+        // Node `Request` / `Response` revivers that don't rely on running an
+        // actual fetch handler — used to render request/response IO inline.
         Request: (value) => {
             // biome-ignore lint/complexity/useArrowFunction: arrow functions have no .prototype
             const ctor = { Request: function () { } }.Request;
@@ -142,14 +217,6 @@ export function getCLIRevivers() {
             });
             return obj;
         },
-        Int8Array: (value) => new Int8Array(reviveArrayBuffer(value)),
-        Int16Array: (value) => new Int16Array(reviveArrayBuffer(value)),
-        Int32Array: (value) => new Int32Array(reviveArrayBuffer(value)),
-        Map: (value) => new Map(value),
-        RegExp: (value) => new RegExp(value.source, value.flags),
-        // O11y-specific revivers (streams, step functions → display objects).
-        // Spread FIRST so CLI-specific overrides below take precedence.
-        ...observabilityRevivers,
         // CLI-specific overrides for class instances with inspect.custom
         Class: (value) => `<class:${extractClassName(value.classId)}>`,
         Instance: (value) => {
@@ -160,13 +227,6 @@ export function getCLIRevivers() {
             }
             return new CLIClassInstanceRef(extractClassName(value.classId), value.classId, value.data);
         },
-        Set: (value) => new Set(value),
-        URL: (value) => new URL(value),
-        URLSearchParams: (value) => new URLSearchParams(value === '.' ? '' : value),
-        Uint8Array: (value) => new Uint8Array(reviveArrayBuffer(value)),
-        Uint8ClampedArray: (value) => new Uint8ClampedArray(reviveArrayBuffer(value)),
-        Uint16Array: (value) => new Uint16Array(reviveArrayBuffer(value)),
-        Uint32Array: (value) => new Uint32Array(reviveArrayBuffer(value)),
     };
 }
 // ---------------------------------------------------------------------------
@@ -201,8 +261,11 @@ async function maybeDecryptFields(resource, resolver) {
     const result = { ...resource };
     try {
         const rawKey = await resolver(runId);
-        const { importKey } = await import('@workflow/core/encryption');
-        const k = rawKey ? await importKey(rawKey) : undefined;
+        // Resolve the full key capability so `--decrypt` can open sealed
+        // ('encp') payloads that other runs wrote to this one, not just the
+        // run's own symmetric ('encr') payloads.
+        const { deriveRunPayloadKeys } = await import('@workflow/core/serialization');
+        const k = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;
         // Decrypt input/output/error fields (WorkflowRun, Step)
         result.input = await maybeDecrypt(result.input, k);
         result.output = await maybeDecrypt(result.output, k);
@@ -212,13 +275,7 @@ async function maybeDecryptFields(resource, resolver) {
         // Decrypt eventData fields (Event)
         if (result.eventData && typeof result.eventData === 'object') {
             const eventData = { ...result.eventData };
-            for (const field of [
-                'result',
-                'input',
-                'output',
-                'metadata',
-                'payload',
-            ]) {
+            for (const field of getEventDataRefFields(result.eventType ?? '')) {
                 eventData[field] = await maybeDecrypt(eventData[field], k);
             }
             result.eventData = eventData;
@@ -264,7 +321,8 @@ function replaceEncryptedAndExpiredWithRef(resource) {
     }
     if (result.eventData && typeof result.eventData === 'object') {
         const ed = { ...result.eventData };
-        for (const key of ['result', 'input', 'output', 'metadata', 'payload']) {
+        const eventType = typeof result.eventType === 'string' ? result.eventType : '';
+        for (const key of getEventDataRefFields(eventType)) {
             ed[key] = toDisplayRef(ed[key]);
         }
         result.eventData = ed;
@@ -287,4 +345,4 @@ export async function hydrateResourceIO(resource, keyResolver) {
     // Post-process: swap encrypted Uint8Arrays and expired stubs for CLI-styled objects
     return replaceEncryptedAndExpiredWithRef(hydrated);
 }
-//# sourceMappingURL=hydration.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hydration.js","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * CLI-specific hydration for o11y display.\n *\n * Node.js revivers that use `Buffer.from()` for base64 decoding and add\n * `util.inspect.custom` to ClassInstanceRef for pretty CLI output.\n */\n\nimport { inspect } from 'node:util';\nimport { getCommonRevivers, maybeDecrypt } from '@workflow/core/serialization';\nimport {\n  ClassInstanceRef,\n  extractClassName,\n  hydrateResourceIO as hydrateResourceIOGeneric,\n  isEncryptedData,\n  isExpiredStub,\n  isRunRef,\n  observabilityRevivers,\n  type Revivers,\n  serializedInstanceToRef,\n} from '@workflow/core/serialization-format';\nimport { parseClassName } from '@workflow/utils/parse-name';\nimport { getEventDataRefFields } from '@workflow/world';\nimport chalk from 'chalk';\n\n/**\n * A function that resolves an encryption key for a run, or null to skip\n * decryption. Accepts a runId — the resolver is responsible for looking\n * up the WorkflowRun internally (with caching) if the World needs it.\n */\nexport type EncryptionKeyResolver =\n  | ((runId: string) => Promise<Uint8Array | undefined>)\n  | null;\n\n// Re-export types and utilities that consumers need\nexport {\n  CLASS_INSTANCE_REF_TYPE,\n  ClassInstanceRef,\n  ENCRYPTED_PLACEHOLDER,\n  extractStreamIds,\n  isClassInstanceRef,\n  isEncryptedData,\n  isStreamId,\n  isStreamRef,\n  type Revivers,\n  STREAM_REF_TYPE,\n  type StreamRef,\n  truncateId,\n} from '@workflow/core/serialization-format';\n\n// ---------------------------------------------------------------------------\n// CLI ClassInstanceRef with inspect.custom\n// ---------------------------------------------------------------------------\n\n/**\n * Extended ClassInstanceRef with Node.js `util.inspect.custom` for\n * pretty CLI output: `ClassName@filename { ...data }`\n */\nclass CLIClassInstanceRef extends ClassInstanceRef {\n  [inspect.custom](\n    _depth: number,\n    options: import('node:util').InspectOptionsStylized\n  ): string {\n    const dataStr = inspect(this.data, { ...options, depth: options.depth });\n    const parsed = parseClassName(this.classId);\n    const moduleSpecifier = parsed?.moduleSpecifier ?? this.classId;\n    const fileName = moduleSpecifier.split('/').pop() ?? moduleSpecifier;\n    const styledFileName = options.stylize\n      ? options.stylize(`@${fileName}`, 'undefined')\n      : `@${fileName}`;\n    return `${this.className}${styledFileName} ${dataStr}`;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// CLI encrypted data placeholder with custom inspect\n// ---------------------------------------------------------------------------\n\n/**\n * Placeholder object for encrypted data fields in CLI output.\n *\n * Uses `util.inspect.custom` to render as a styled, unquoted string\n * (e.g., dim yellow \"🔒 Encrypted\") instead of a plain quoted string.\n * Also provides `toJSON()` for `--json` output.\n */\nclass EncryptedDataRef {\n  [inspect.custom](): string {\n    return chalk.dim.yellow('\\u{1F512} Encrypted');\n  }\n\n  toJSON(): string {\n    return '\\u{1F512} Encrypted';\n  }\n\n  toString(): string {\n    return '\\u{1F512} Encrypted';\n  }\n}\n\n/** Singleton encrypted data placeholder for CLI display */\nconst ENCRYPTED_REF = new EncryptedDataRef();\n\n/** Check if a value is an EncryptedDataRef (for custom table formatting in CLI) */\nexport function isEncryptedRef(value: unknown): value is EncryptedDataRef {\n  return value instanceof EncryptedDataRef;\n}\n\n// ---------------------------------------------------------------------------\n// CLI expired data placeholder with custom inspect\n// ---------------------------------------------------------------------------\n\n/**\n * Placeholder object for expired data fields in CLI output.\n *\n * Uses `util.inspect.custom` to render as a styled, unquoted string\n * (e.g., dim gray \"<data expired>\") instead of a raw stub object.\n * Also provides `toJSON()` for `--json` output.\n */\nclass ExpiredDataRef {\n  [inspect.custom](): string {\n    return chalk.gray('<data expired>');\n  }\n\n  toJSON(): string {\n    return '<data expired>';\n  }\n\n  toString(): string {\n    return '<data expired>';\n  }\n}\n\n/** Singleton expired data placeholder for CLI display */\nconst EXPIRED_REF = new ExpiredDataRef();\n\n/** Check if a value is an ExpiredDataRef (for custom table formatting in CLI) */\nexport function isExpiredRef(value: unknown): value is ExpiredDataRef {\n  return value instanceof ExpiredDataRef;\n}\n\n// ---------------------------------------------------------------------------\n// CLI revivers (Node.js, uses Buffer)\n// ---------------------------------------------------------------------------\n\n/**\n * The set of reducer keys whose `getCommonRevivers()` output produces a\n * native `Error` instance. We wrap each of these with an additional\n * `toJSON` attachment in CLI mode (see `wrapErrorReviverWithToJSON`).\n */\nconst ERROR_REVIVER_KEYS = [\n  'AggregateError',\n  'DOMException',\n  'Error',\n  'EvalError',\n  'FatalError',\n  'HookConflictError',\n  'RangeError',\n  'ReferenceError',\n  'RetryableError',\n  'RuntimeDecryptionError',\n  'SyntaxError',\n  'TypeError',\n  'URIError',\n] as const;\n\n/**\n * Wraps a runtime Error reviver so that the produced instance carries a\n * non-enumerable `toJSON` method. The runtime revivers return real `Error`\n * instances (good for `util.inspect`, `instanceof`, `toString`, etc.), but\n * `Error.prototype`'s `name` / `message` / `stack` / `cause` are\n * non-enumerable and would be dropped by `JSON.stringify` — which is how\n * the CLI emits its `--json` output. Adding `toJSON` (which `JSON.stringify`\n * calls but `util.inspect` ignores) gives us the best of both worlds:\n * round-tripped errors render cleanly in both modes without the\n * data-versus-display tradeoff that plain-object revivers would force.\n *\n * Subclass-specific enumerable fields (e.g. `RetryableError.retryAfter`,\n * `AggregateError.errors`, `FatalError.fatal`) are picked up automatically\n * via `Object.assign` after the base fields, so we don't have to enumerate\n * them per-subclass.\n */\nfunction wrapErrorReviverWithToJSON(\n  reviver: (value: any) => unknown\n): (value: any) => unknown {\n  return (value) => {\n    const result = reviver(value);\n    if (!(result instanceof Error)) return result;\n    Object.defineProperty(result, 'toJSON', {\n      value: function (this: Error) {\n        const json: Record<string, unknown> = {\n          name: this.name,\n          message: this.message,\n          stack: this.stack,\n        };\n        if ('cause' in this) {\n          json.cause = (this as { cause: unknown }).cause;\n        }\n        // Pick up subclass-specific enumerable fields (e.g. FatalError.fatal,\n        // RetryableError.retryAfter, AggregateError.errors).\n        Object.assign(json, this);\n        return json;\n      },\n      enumerable: false,\n      writable: true,\n      configurable: true,\n    });\n    return result;\n  };\n}\n\n/**\n * The set of revivers used by CLI inspect output.\n *\n * Built on top of `getCommonRevivers()` from `@workflow/core` so that the\n * CLI stays in sync with the runtime's reviver set automatically. Without\n * this, every new reviver added to core (e.g. `FatalError`,\n * `RetryableError`, the built-in `Error` subclasses) would silently\n * disappear from CLI output: devalue throws \"Unknown type X\" for\n * unrecognized reduced types, and `hydrateResourceIO` swallows that error\n * and surfaces the raw `Uint8Array` payload to consumers — which then\n * shows up as `step.error` / `run.error` byte dumps instead of usable\n * `{ message, stack, … }` objects.\n *\n * On top of the common set we layer:\n *   - A `toJSON` shim on each Error reviver so non-enumerable\n *     `Error.prototype` fields survive `JSON.stringify` for `--json` output\n *     while leaving `util.inspect` rendering untouched\n *   - `observabilityRevivers` for streams / step+workflow function refs\n *   - CLI-specific overrides that produce display-friendly placeholders\n *     for `Class` / `Instance` (the runtime versions need full class\n *     identity which the CLI doesn't have access to)\n */\nexport function getCLIRevivers(): Revivers {\n  const baseRevivers = getCommonRevivers(globalThis);\n  const errorRevivers = Object.fromEntries(\n    ERROR_REVIVER_KEYS.flatMap((key) => {\n      const reviver = (baseRevivers as Revivers)[key];\n      return reviver ? [[key, wrapErrorReviverWithToJSON(reviver)]] : [];\n    })\n  );\n  return {\n    ...baseRevivers,\n    ...errorRevivers,\n    // O11y-specific revivers (streams, step functions → display objects).\n    ...observabilityRevivers,\n    // Node `Request` / `Response` revivers that don't rely on running an\n    // actual fetch handler — used to render request/response IO inline.\n    Request: (value) => {\n      // biome-ignore lint/complexity/useArrowFunction: arrow functions have no .prototype\n      const ctor = { Request: function () {} }.Request!;\n      const obj = Object.create(ctor.prototype);\n      Object.assign(obj, {\n        method: value.method,\n        url: value.url,\n        headers: new Headers(value.headers),\n        body: value.body,\n        duplex: value.duplex,\n        ...(value.responseWritable\n          ? { responseWritable: value.responseWritable }\n          : {}),\n      });\n      return obj;\n    },\n    Response: (value) => {\n      // biome-ignore lint/complexity/useArrowFunction: arrow functions have no .prototype\n      const ctor = { Response: function () {} }.Response!;\n      const obj = Object.create(ctor.prototype);\n      Object.assign(obj, {\n        status: value.status,\n        statusText: value.statusText,\n        url: value.url,\n        headers: new Headers(value.headers),\n        body: value.body,\n        redirected: value.redirected,\n        type: value.type,\n      });\n      return obj;\n    },\n    // CLI-specific overrides for class instances with inspect.custom\n    Class: (value) => `<class:${extractClassName(value.classId)}>`,\n    Instance: (value) => {\n      // Run instances are rendered as RunRef for clickable rendering\n      const runRef = serializedInstanceToRef(value);\n      if (isRunRef(runRef)) {\n        return runRef;\n      }\n      return new CLIClassInstanceRef(\n        extractClassName(value.classId),\n        value.classId,\n        value.data\n      );\n    },\n  };\n}\n\n// ---------------------------------------------------------------------------\n// Pre-built CLI revivers (cached)\n// ---------------------------------------------------------------------------\n\nlet cachedRevivers: Revivers | null = null;\n\nfunction getRevivers(): Revivers {\n  if (!cachedRevivers) {\n    cachedRevivers = getCLIRevivers();\n  }\n  return cachedRevivers;\n}\n\n// ---------------------------------------------------------------------------\n// Decryption helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Pre-process a resource's data fields: if the resolver is provided and\n * the field is encrypted, decrypt it before generic hydration.\n *\n * Uses core's `maybeDecrypt()` which handles the 'encr' prefix stripping\n * and AES-GCM decryption transparently.\n *\n * When the resolver is null (no --decrypt flag), encrypted fields pass\n * through as Uint8Array and are replaced with EncryptedDataRef in post-processing.\n */\nasync function maybeDecryptFields<\n  T extends {\n    runId?: string;\n    input?: any;\n    output?: any;\n    metadata?: any;\n    eventType?: string;\n    eventData?: any;\n  },\n>(resource: T, resolver: EncryptionKeyResolver): Promise<T> {\n  if (!resolver) return resource;\n\n  const runId = (resource as any).runId as string | undefined;\n  if (!runId) return resource;\n\n  const result = { ...resource };\n\n  try {\n    const rawKey = await resolver(runId);\n    // Resolve the full key capability so `--decrypt` can open sealed\n    // ('encp') payloads that other runs wrote to this one, not just the\n    // run's own symmetric ('encr') payloads.\n    const { deriveRunPayloadKeys } = await import(\n      '@workflow/core/serialization'\n    );\n    const k = rawKey ? await deriveRunPayloadKeys(rawKey) : undefined;\n\n    // Decrypt input/output/error fields (WorkflowRun, Step)\n    result.input = await maybeDecrypt(result.input, k);\n    result.output = await maybeDecrypt(result.output, k);\n    (result as any).error = await maybeDecrypt((result as any).error, k);\n\n    // Decrypt metadata field (Hook)\n    result.metadata = await maybeDecrypt(result.metadata, k);\n\n    // Decrypt eventData fields (Event)\n    if (result.eventData && typeof result.eventData === 'object') {\n      const eventData = { ...result.eventData };\n      for (const field of getEventDataRefFields(result.eventType ?? '')) {\n        eventData[field] = await maybeDecrypt(eventData[field], k);\n      }\n      result.eventData = eventData;\n    }\n  } catch (err) {\n    const message = err instanceof Error ? err.message : String(err);\n\n    // If the key fetch failed due to an HTTP error (e.g. 429 rate limit,\n    // 500 server error), re-throw so the caller surfaces a clear failure\n    // instead of silently showing encrypted placeholders.\n    if (message.includes('HTTP ')) {\n      throw err;\n    }\n\n    // Decryption failed (bad key, corrupted ciphertext, etc.) — fall back\n    // to showing encrypted placeholders instead of crashing the CLI.\n    const { logger } = await import('../config/log.js');\n    logger.warn(`Decryption failed for resource ${runId}: ${message}`);\n  }\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/** Replace a single field value with a display ref if it's encrypted or expired. */\nfunction toDisplayRef(value: unknown): unknown {\n  if (isEncryptedData(value)) return ENCRYPTED_REF;\n  if (isExpiredStub(value)) return EXPIRED_REF;\n  return value;\n}\n\n/**\n * Replace encrypted Uint8Array values and expired stubs with styled\n * ref objects in known data fields for custom inspect rendering.\n */\nfunction replaceEncryptedAndExpiredWithRef<T>(resource: T): T {\n  if (!resource || typeof resource !== 'object') return resource;\n  const r = resource as Record<string, unknown>;\n  const result = { ...r };\n\n  for (const key of ['input', 'output', 'metadata', 'error']) {\n    result[key] = toDisplayRef(result[key]);\n  }\n\n  if (result.eventData && typeof result.eventData === 'object') {\n    const ed = { ...(result.eventData as Record<string, unknown>) };\n    const eventType =\n      typeof result.eventType === 'string' ? result.eventType : '';\n    for (const key of getEventDataRefFields(eventType)) {\n      ed[key] = toDisplayRef(ed[key]);\n    }\n    result.eventData = ed;\n  }\n\n  return result as T;\n}\n\n/**\n * Hydrate the serialized data fields of a resource for CLI display.\n *\n * When `encryptorResolver` is null (default / no --decrypt flag), encrypted\n * fields are shown as styled \"🔒 Encrypted\" placeholders via EncryptedDataRef.\n *\n * When `encryptorResolver` is provided (--decrypt flag), encrypted fields\n * are decrypted before hydration so the actual user data is displayed.\n */\nexport async function hydrateResourceIO<T>(\n  resource: T,\n  keyResolver?: EncryptionKeyResolver\n): Promise<T> {\n  // Pre-process: decrypt any encrypted fields when a resolver is provided\n  const preprocessed = await maybeDecryptFields(\n    resource as any,\n    keyResolver ?? null\n  );\n  const hydrated = hydrateResourceIOGeneric(preprocessed, getRevivers()) as T;\n  // Post-process: swap encrypted Uint8Arrays and expired stubs for CLI-styled objects\n  return replaceEncryptedAndExpiredWithRef(hydrated);\n}\n"]}

package/dist/lib/inspect/hydration.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hydration.test.d.ts.map

package/dist/lib/inspect/hydration.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration.test.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/hydration.test.ts"],"names":[],"mappings":""}

package/dist/lib/inspect/hydration.test.js

@@ -0,0 +1,23 @@
+import { importKey } from '@workflow/core/encryption';
+import { dehydrateStepError } from '@workflow/core/serialization';
+import { describe, expect, it } from 'vitest';
+import { hydrateResourceIO, isEncryptedRef } from './hydration.js';
+describe('hydrateResourceIO', () => {
+    it('displays and decrypts encrypted event errors', async () => {
+        const rawKey = new Uint8Array(32).fill(7);
+        const error = new Error('step failed');
+        const encryptedError = await dehydrateStepError(error, 'run_1', await importKey(rawKey), [], globalThis, true);
+        const event = {
+            runId: 'run_1',
+            eventId: 'event_1',
+            eventType: 'step_failed',
+            eventData: { error: encryptedError },
+        };
+        const encrypted = await hydrateResourceIO(event);
+        expect(isEncryptedRef(encrypted.eventData.error)).toBe(true);
+        const decrypted = await hydrateResourceIO(event, async () => rawKey);
+        expect(decrypted.eventData.error).toBeInstanceOf(Error);
+        expect(decrypted.eventData.error).toHaveProperty('message', error.message);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHlkcmF0aW9uLnRlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2luc3BlY3QvaHlkcmF0aW9uLnRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLDJCQUEyQixDQUFDO0FBQ3RELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxFQUFFLEVBQUUsRUFBRSxNQUFNLFFBQVEsQ0FBQztBQUM5QyxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsY0FBYyxFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFbkUsUUFBUSxDQUFDLG1CQUFtQixFQUFFLEdBQUcsRUFBRTtJQUNqQyxFQUFFLENBQUMsOENBQThDLEVBQUUsS0FBSyxJQUFJLEVBQUU7UUFDNUQsTUFBTSxNQUFNLEdBQUcsSUFBSSxVQUFVLENBQUMsRUFBRSxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzFDLE1BQU0sS0FBSyxHQUFHLElBQUksS0FBSyxDQUFDLGFBQWEsQ0FBQyxDQUFDO1FBQ3ZDLE1BQU0sY0FBYyxHQUFHLE1BQU0sa0JBQWtCLENBQzdDLEtBQUssRUFDTCxPQUFPLEVBQ1AsTUFBTSxTQUFTLENBQUMsTUFBTSxDQUFDLEVBQ3ZCLEVBQUUsRUFDRixVQUFVLEVBQ1YsSUFBSSxDQUNMLENBQUM7UUFDRixNQUFNLEtBQUssR0FBRztZQUNaLEtBQUssRUFBRSxPQUFPO1lBQ2QsT0FBTyxFQUFFLFNBQVM7WUFDbEIsU0FBUyxFQUFFLGFBQWE7WUFDeEIsU0FBUyxFQUFFLEVBQUUsS0FBSyxFQUFFLGNBQWMsRUFBRTtTQUNyQyxDQUFDO1FBRUYsTUFBTSxTQUFTLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUNqRCxNQUFNLENBQUMsY0FBYyxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLENBQUM7UUFFN0QsTUFBTSxTQUFTLEdBQUcsTUFBTSxpQkFBaUIsQ0FBQyxLQUFLLEVBQUUsS0FBSyxJQUFJLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUNyRSxNQUFNLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxLQUFLLENBQUMsQ0FBQyxjQUFjLENBQUMsS0FBSyxDQUFDLENBQUM7UUFDeEQsTUFBTSxDQUFDLFNBQVMsQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLENBQUMsY0FBYyxDQUFDLFNBQVMsRUFBRSxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDN0UsQ0FBQyxDQUFDLENBQUM7QUFDTCxDQUFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGltcG9ydEtleSB9IGZyb20gJ0B3b3JrZmxvdy9jb3JlL2VuY3J5cHRpb24nO1xuaW1wb3J0IHsgZGVoeWRyYXRlU3RlcEVycm9yIH0gZnJvbSAnQHdvcmtmbG93L2NvcmUvc2VyaWFsaXphdGlvbic7XG5pbXBvcnQgeyBkZXNjcmliZSwgZXhwZWN0LCBpdCB9IGZyb20gJ3ZpdGVzdCc7XG5pbXBvcnQgeyBoeWRyYXRlUmVzb3VyY2VJTywgaXNFbmNyeXB0ZWRSZWYgfSBmcm9tICcuL2h5ZHJhdGlvbi5qcyc7XG5cbmRlc2NyaWJlKCdoeWRyYXRlUmVzb3VyY2VJTycsICgpID0+IHtcbiAgaXQoJ2Rpc3BsYXlzIGFuZCBkZWNyeXB0cyBlbmNyeXB0ZWQgZXZlbnQgZXJyb3JzJywgYXN5bmMgKCkgPT4ge1xuICAgIGNvbnN0IHJhd0tleSA9IG5ldyBVaW50OEFycmF5KDMyKS5maWxsKDcpO1xuICAgIGNvbnN0IGVycm9yID0gbmV3IEVycm9yKCdzdGVwIGZhaWxlZCcpO1xuICAgIGNvbnN0IGVuY3J5cHRlZEVycm9yID0gYXdhaXQgZGVoeWRyYXRlU3RlcEVycm9yKFxuICAgICAgZXJyb3IsXG4gICAgICAncnVuXzEnLFxuICAgICAgYXdhaXQgaW1wb3J0S2V5KHJhd0tleSksXG4gICAgICBbXSxcbiAgICAgIGdsb2JhbFRoaXMsXG4gICAgICB0cnVlXG4gICAgKTtcbiAgICBjb25zdCBldmVudCA9IHtcbiAgICAgIHJ1bklkOiAncnVuXzEnLFxuICAgICAgZXZlbnRJZDogJ2V2ZW50XzEnLFxuICAgICAgZXZlbnRUeXBlOiAnc3RlcF9mYWlsZWQnLFxuICAgICAgZXZlbnREYXRhOiB7IGVycm9yOiBlbmNyeXB0ZWRFcnJvciB9LFxuICAgIH07XG5cbiAgICBjb25zdCBlbmNyeXB0ZWQgPSBhd2FpdCBoeWRyYXRlUmVzb3VyY2VJTyhldmVudCk7XG4gICAgZXhwZWN0KGlzRW5jcnlwdGVkUmVmKGVuY3J5cHRlZC5ldmVudERhdGEuZXJyb3IpKS50b0JlKHRydWUpO1xuXG4gICAgY29uc3QgZGVjcnlwdGVkID0gYXdhaXQgaHlkcmF0ZVJlc291cmNlSU8oZXZlbnQsIGFzeW5jICgpID0+IHJhd0tleSk7XG4gICAgZXhwZWN0KGRlY3J5cHRlZC5ldmVudERhdGEuZXJyb3IpLnRvQmVJbnN0YW5jZU9mKEVycm9yKTtcbiAgICBleHBlY3QoZGVjcnlwdGVkLmV2ZW50RGF0YS5lcnJvcikudG9IYXZlUHJvcGVydHkoJ21lc3NhZ2UnLCBlcnJvci5tZXNzYWdlKTtcbiAgfSk7XG59KTtcbiJdfQ==

package/dist/lib/inspect/output.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRun, WorkflowRunWithoutData, World } from '@workflow/world';
+import { type WorkflowRun, type World } from '@workflow/world';
 import type { InspectCLIOptions } from '../config/types.js';
 import { getDisplaySettings } from './terminal-utils.js';
 export declare const formatTableValue: (prop: string, value: unknown, opts?: InspectCLIOptions, displaySettings?: ReturnType<typeof getDisplaySettings>, item?: Record<string, unknown>) => unknown;
@@ -8,7 +8,7 @@ export declare const formatTableValue: (prop: string, value: unknown, opts?: Ins
  */
 export declare const hasExpiredData: (run: WorkflowRun) => boolean;
 export declare const listRuns: (world: World, opts?: InspectCLIOptions) => Promise<void>;
-export declare const getRecentRun: (world: World, opts?: InspectCLIOptions) => Promise<WorkflowRunWithoutData>;
+export declare const getRecentRun: (world: World, opts?: InspectCLIOptions) => Promise<import("@workflow/world").WorkflowRunWithoutData>;
 export declare const showRun: (world: World, runId: string, opts?: InspectCLIOptions) => Promise<void>;
 export declare const listSteps: (world: World, opts?: InspectCLIOptions) => Promise<void>;
 export declare const showStep: (world: World, stepId: string, opts?: InspectCLIOptions) => Promise<void>;

package/dist/lib/inspect/output.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/output.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAOV,WAAW,EACX,sBAAsB,EACtB,KAAK,EACN,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAiC5D,OAAO,EAGL,kBAAkB,EAGnB,MAAM,qBAAqB,CAAC;AAuN7B,eAAO,MAAM,gBAAgB,GAC3B,MAAM,MAAM,EACZ,OAAO,OAAO,EACd,OAAM,iBAAsB,EAC5B,kBAAkB,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACvD,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAsE/B,CAAC;AA8IF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,WAAW,KAAG,OAMjD,CAAC;AA4DF,eAAO,MAAM,QAAQ,GAAU,OAAO,KAAK,EAAE,OAAM,iBAAsB,kBA8ExE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,OAAO,KAAK,EACZ,OAAM,iBAAsB,oCAoB7B,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,OAAO,KAAK,EACZ,OAAO,MAAM,EACb,OAAM,iBAAsB,kBA2B7B,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,OAAO,KAAK,EACZ,OAAM,iBAEL,kBA2FF,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,QAAQ,MAAM,EACd,OAAM,iBAAsB,kBA+C7B,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,UAAU,MAAM,EAChB,OAAM,iBAAsB,kBA2C7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBAgD7B,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBA2F7B,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,OAAO,KAAK,EAAE,OAAM,iBAAsB,kBAuFzE,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,QAAQ,MAAM,EACd,OAAM,iBAAsB,kBA+B7B,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBAsH7B,CAAC"}
+{"version":3,"file":"output.d.ts","sourceRoot":"","sources":["../../../src/lib/inspect/output.ts"],"names":[],"mappings":"AAQA,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,KAAK,EACX,MAAM,iBAAiB,CAAC;AAMzB,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AA0C5D,OAAO,EAGL,kBAAkB,EAGnB,MAAM,qBAAqB,CAAC;AAuO7B,eAAO,MAAM,gBAAgB,GAC3B,MAAM,MAAM,EACZ,OAAO,OAAO,EACd,OAAM,iBAAsB,EAC5B,kBAAkB,UAAU,CAAC,OAAO,kBAAkB,CAAC,EACvD,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,YAuE/B,CAAC;AAuLF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,WAAW,KAAG,OAMjD,CAAC;AA4EF,eAAO,MAAM,QAAQ,GAAU,OAAO,KAAK,EAAE,OAAM,iBAAsB,kBAyIxE,CAAC;AAEF,eAAO,MAAM,YAAY,GACvB,OAAO,KAAK,EACZ,OAAM,iBAAsB,8DAoB7B,CAAC;AAEF,eAAO,MAAM,OAAO,GAClB,OAAO,KAAK,EACZ,OAAO,MAAM,EACb,OAAM,iBAAsB,kBAwC7B,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,OAAO,KAAK,EACZ,OAAM,iBAEL,kBA2GF,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,QAAQ,MAAM,EACd,OAAM,iBAAsB,kBA+C7B,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,UAAU,MAAM,EAChB,OAAM,iBAAsB,kBA6C7B,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBAgD7B,CAAC;AAEF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBA0G7B,CAAC;AAEF,eAAO,MAAM,SAAS,GAAU,OAAO,KAAK,EAAE,OAAM,iBAAsB,kBA6EzE,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,OAAO,KAAK,EACZ,QAAQ,MAAM,EACd,OAAM,iBAAsB,kBA+B7B,CAAC;AAqDF,eAAO,MAAM,UAAU,GACrB,OAAO,KAAK,EACZ,OAAM,iBAAsB,kBAmI7B,CAAC"}