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

package/dist/global.js

@@ -1,3 +1,4 @@
+import { WorkflowRuntimeError } from '@workflow/errors';
 import { pluralize } from '@workflow/utils';
 /**
  * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do
@@ -11,7 +12,9 @@ export class WorkflowSuspension extends Error {
     stepCount;
     hookCount;
     waitCount;
+    attributeCount;
     hookDisposedCount;
+    abortCount;
     constructor(stepsInput, global) {
         // Convert Map to array for iteration and storage
         const steps = [...stepsInput.values()];
@@ -19,18 +22,24 @@ export class WorkflowSuspension extends Error {
         let stepCount = 0;
         let hookCount = 0;
         let waitCount = 0;
+        let attributeCount = 0;
         let hookDisposedCount = 0;
+        let abortCount = 0;
         for (const item of steps) {
             if (item.type === 'step')
                 stepCount++;
             else if (item.type === 'hook') {
                 if (item.disposed)
                     hookDisposedCount++;
+                else if (item.abortRequested)
+                    abortCount++;
                 else
                     hookCount++;
             }
             else if (item.type === 'wait')
                 waitCount++;
+            else if (item.type === 'attribute')
+                attributeCount++;
         }
         // Build description parts
         const parts = [];
@@ -43,16 +52,20 @@ export class WorkflowSuspension extends Error {
         if (waitCount > 0) {
             parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);
         }
+        if (attributeCount > 0) {
+            parts.push(`${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`);
+        }
         if (hookDisposedCount > 0) {
             parts.push(`${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`);
         }
         // Determine verb (has/have) and action (run/created/received)
-        const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;
+        const totalCount = stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;
         const hasOrHave = pluralize('has', 'have', totalCount);
         // Pick action verb: use "processed" when mixed types are present
         const typeCount = (stepCount > 0 ? 1 : 0) +
             (hookCount > 0 ? 1 : 0) +
             (waitCount > 0 ? 1 : 0) +
+            (attributeCount > 0 ? 1 : 0) +
             (hookDisposedCount > 0 ? 1 : 0);
         let action;
         if (typeCount > 1) {
@@ -67,6 +80,9 @@ export class WorkflowSuspension extends Error {
         else if (waitCount > 0) {
             action = 'created';
         }
+        else if (attributeCount > 0) {
+            action = 'written';
+        }
         else if (hookDisposedCount > 0) {
             action = 'processed';
         }
@@ -83,13 +99,15 @@ export class WorkflowSuspension extends Error {
         this.stepCount = stepCount;
         this.hookCount = hookCount;
         this.waitCount = waitCount;
+        this.attributeCount = attributeCount;
         this.hookDisposedCount = hookDisposedCount;
+        this.abortCount = abortCount;
     }
     static is(value) {
         return value instanceof WorkflowSuspension;
     }
 }
 export function ENOTSUP() {
-    throw new Error('Not supported in workflow functions');
+    throw new WorkflowRuntimeError('This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.');
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { pluralize } from '@workflow/utils';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  hookDisposedCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let hookDisposedCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount = stepCount + hookCount + waitCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.hookDisposedCount = hookDisposedCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new Error('Not supported in workflow functions');\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global.js","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"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","sourcesContent":["import { WorkflowRuntimeError } from '@workflow/errors';\nimport { pluralize } from '@workflow/utils';\nimport type { AttributeChange } from '@workflow/world';\nimport type { Serializable } from './schemas.js';\n\nexport interface StepInvocationQueueItem {\n  type: 'step';\n  correlationId: string;\n  stepName: string;\n  args: Serializable[];\n  closureVars?: Record<string, Serializable>;\n  thisVal?: Serializable;\n  hasCreatedEvent?: boolean;\n  /**\n   * Inline step ownership, derived from the step's LATEST `step_started`\n   * during replay: the queue message ID stamped by the invocation running\n   * the step inline, or undefined when the latest start was unstamped (a\n   * retry attempt driven by a queued step message, or an older runtime).\n   * Latest start wins — an unstamped bare start clears a previous stamp; an\n   * owner-recovery re-stamped start restores it.\n   */\n  ownerMessageId?: string;\n  /**\n   * `createdAt` (ms) of the step's latest observed `step_started`. Anchors\n   * the ownership lease: `leaseRemaining = lastStartedAt + lease − now`.\n   */\n  lastStartedAt?: number;\n  /**\n   * Whether a `step_retrying` was observed for this step. From that point\n   * the step is queue-owned (the delayed retry handoff or replay requeue),\n   * so inline ownership is permanently lapsed for this correlation ID.\n   */\n  sawRetrying?: boolean;\n}\n\nexport interface HookInvocationQueueItem {\n  type: 'hook';\n  correlationId: string;\n  token: string;\n  /** Earliest time the token can be reused after the run ends. */\n  tokenRetentionUntil?: Date;\n  metadata?: Serializable;\n  hasCreatedEvent?: boolean;\n  /** Whether the workflow is awaiting `hook.getConflict()` for this hook */\n  hasConflictAwaiter?: boolean;\n  disposed?: boolean;\n  isWebhook?: boolean;\n  isSystem?: boolean;\n  abortRequested?: boolean;\n  abortReason?: unknown;\n}\n\nexport interface WaitInvocationQueueItem {\n  type: 'wait';\n  correlationId: string;\n  resumeAt: Date;\n  hasCreatedEvent?: boolean;\n}\n\nexport interface AttributeInvocationQueueItem {\n  type: 'attribute';\n  correlationId: string;\n  changes: AttributeChange[];\n  allowReservedAttributes?: true;\n}\n\nexport type QueueItem =\n  | StepInvocationQueueItem\n  | HookInvocationQueueItem\n  | WaitInvocationQueueItem\n  | AttributeInvocationQueueItem;\n\n/**\n * An error that is thrown when one or more operations (steps/hooks/etc.) are called but do\n * not yet have corresponding entries in the event log. The workflow\n * dispatcher will catch this error and push the operations\n * onto the queue.\n */\nexport class WorkflowSuspension extends Error {\n  steps: QueueItem[];\n  globalThis: typeof globalThis;\n  stepCount: number;\n  hookCount: number;\n  waitCount: number;\n  attributeCount: number;\n  hookDisposedCount: number;\n  abortCount: number;\n\n  constructor(stepsInput: Map<string, QueueItem>, global: typeof globalThis) {\n    // Convert Map to array for iteration and storage\n    const steps = [...stepsInput.values()];\n\n    // Single-pass counting for efficiency\n    let stepCount = 0;\n    let hookCount = 0;\n    let waitCount = 0;\n    let attributeCount = 0;\n    let hookDisposedCount = 0;\n    let abortCount = 0;\n    for (const item of steps) {\n      if (item.type === 'step') stepCount++;\n      else if (item.type === 'hook') {\n        if (item.disposed) hookDisposedCount++;\n        else if (item.abortRequested) abortCount++;\n        else hookCount++;\n      } else if (item.type === 'wait') waitCount++;\n      else if (item.type === 'attribute') attributeCount++;\n    }\n\n    // Build description parts\n    const parts: string[] = [];\n    if (stepCount > 0) {\n      parts.push(`${stepCount} ${pluralize('step', 'steps', stepCount)}`);\n    }\n    if (hookCount > 0) {\n      parts.push(`${hookCount} ${pluralize('hook', 'hooks', hookCount)}`);\n    }\n    if (waitCount > 0) {\n      parts.push(`${waitCount} ${pluralize('wait', 'waits', waitCount)}`);\n    }\n    if (attributeCount > 0) {\n      parts.push(\n        `${attributeCount} ${pluralize('attribute write', 'attribute writes', attributeCount)}`\n      );\n    }\n    if (hookDisposedCount > 0) {\n      parts.push(\n        `${hookDisposedCount} hook ${pluralize('disposal', 'disposals', hookDisposedCount)}`\n      );\n    }\n\n    // Determine verb (has/have) and action (run/created/received)\n    const totalCount =\n      stepCount + hookCount + waitCount + attributeCount + hookDisposedCount;\n    const hasOrHave = pluralize('has', 'have', totalCount);\n    // Pick action verb: use \"processed\" when mixed types are present\n    const typeCount =\n      (stepCount > 0 ? 1 : 0) +\n      (hookCount > 0 ? 1 : 0) +\n      (waitCount > 0 ? 1 : 0) +\n      (attributeCount > 0 ? 1 : 0) +\n      (hookDisposedCount > 0 ? 1 : 0);\n    let action: string;\n    if (typeCount > 1) {\n      action = 'processed';\n    } else if (stepCount > 0) {\n      action = 'run';\n    } else if (hookCount > 0) {\n      action = 'created';\n    } else if (waitCount > 0) {\n      action = 'created';\n    } else if (attributeCount > 0) {\n      action = 'written';\n    } else if (hookDisposedCount > 0) {\n      action = 'processed';\n    } else {\n      action = 'received';\n    }\n\n    const description =\n      parts.length > 0\n        ? `${parts.join(' and ')} ${hasOrHave} not been ${action} yet`\n        : '0 steps have not been run yet'; // Default case for empty array\n    super(description);\n    this.name = 'WorkflowSuspension';\n    this.steps = steps;\n    this.globalThis = global;\n    this.stepCount = stepCount;\n    this.hookCount = hookCount;\n    this.waitCount = waitCount;\n    this.attributeCount = attributeCount;\n    this.hookDisposedCount = hookDisposedCount;\n    this.abortCount = abortCount;\n  }\n\n  static is(value: unknown): value is WorkflowSuspension {\n    return value instanceof WorkflowSuspension;\n  }\n}\n\nexport function ENOTSUP(): never {\n  throw new WorkflowRuntimeError(\n    'This API is not available inside a workflow function. Workflow functions run in a deterministic VM; move the call to a step function for full Node.js access.'\n  );\n}\n"]}

package/dist/index.d.ts

@@ -12,6 +12,7 @@
 export { FatalError, RetryableError, type RetryableErrorOptions, } from '@workflow/errors';
 export { createHook, createWebhook, type Hook, type HookOptions, type RequestWithResponse, type Webhook, type WebhookOptions, } from './create-hook.js';
 export { defineHook, type TypedHook } from './define-hook.js';
+export { type SetAttributesOptions, setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, type StepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, type WorkflowMetadata, } from './step/get-workflow-metadata.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,UAAU,EACV,cAAc,EACd,KAAK,qBAAqB,GAC3B,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EACL,UAAU,EACV,aAAa,EACb,KAAK,IAAI,EACT,KAAK,WAAW,EAChB,KAAK,mBAAmB,EACxB,KAAK,OAAO,EACZ,KAAK,cAAc,GACpB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC9D,OAAO,EACL,KAAK,oBAAoB,EACzB,aAAa,GACd,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AACnC,OAAO,EACL,eAAe,EACf,KAAK,YAAY,GAClB,MAAM,6BAA6B,CAAC;AACrC,OAAO,EACL,mBAAmB,EACnB,KAAK,gBAAgB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EACL,WAAW,EACX,KAAK,6BAA6B,GACnC,MAAM,2BAA2B,CAAC"}

package/dist/index.js

@@ -12,8 +12,9 @@
 export { FatalError, RetryableError, } from '@workflow/errors';
 export { createHook, createWebhook, } from './create-hook.js';
 export { defineHook } from './define-hook.js';
+export { setAttributes, } from './set-attributes.js';
 export { sleep } from './sleep.js';
 export { getStepMetadata, } from './step/get-step-metadata.js';
 export { getWorkflowMetadata, } from './step/get-workflow-metadata.js';
 export { getWritable, } from './step/writable-stream.js';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/log-format.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Structured-log composition for `console.error` / `console.warn`. Emits
+ * one string in three sections so the most useful information is at the
+ * top, stack trace at the bottom:
+ *
+ *     [workflow-sdk] <framing line>
+ *       user error · FatalError
+ *       run    wrun_…
+ *       step   step_… · add (./workflows/x)
+ *       hint:  Move the call to a step function.
+ *     FatalError: …
+ *         at … (trimmed stack — internals collapsed)
+ *
+ * Without this composition, callers passing `${framing}\n${stack}` as the
+ * message and structured fields as the metadata object got `util.inspect`'s
+ * default object dump appended *after* the stack, which buries the run ID
+ * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.
+ *
+ * The same metadata is also emitted as structured OTel span events from
+ * the logger itself, so backends that want JSON-shaped data still get it.
+ * web/web-shared do not consume stderr at all — they read CBOR/JSON event
+ * payloads from the World event log.
+ */
+export declare function composeLogLine(prefix: string, message: string, metadata: Record<string, unknown> | undefined): string;
+//# sourceMappingURL=log-format.d.ts.map

package/dist/log-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-format.d.ts","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,GAC5C,MAAM,CAUR"}

package/dist/log-format.js

@@ -0,0 +1,250 @@
+import * as Ansi from '@workflow/errors/ansi';
+import { formatStepName, formatWorkflowName, parseStepName, parseWorkflowName, } from '@workflow/utils';
+/**
+ * Structured-log composition for `console.error` / `console.warn`. Emits
+ * one string in three sections so the most useful information is at the
+ * top, stack trace at the bottom:
+ *
+ *     [workflow-sdk] <framing line>
+ *       user error · FatalError
+ *       run    wrun_…
+ *       step   step_… · add (./workflows/x)
+ *       hint:  Move the call to a step function.
+ *     FatalError: …
+ *         at … (trimmed stack — internals collapsed)
+ *
+ * Without this composition, callers passing `${framing}\n${stack}` as the
+ * message and structured fields as the metadata object got `util.inspect`'s
+ * default object dump appended *after* the stack, which buries the run ID
+ * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.
+ *
+ * The same metadata is also emitted as structured OTel span events from
+ * the logger itself, so backends that want JSON-shaped data still get it.
+ * web/web-shared do not consume stderr at all — they read CBOR/JSON event
+ * payloads from the World event log.
+ */
+export function composeLogLine(prefix, message, metadata) {
+    const [framing, ...rest] = message.split('\n');
+    const body = rest.join('\n');
+    const fields = renderStructuredFields(framing ?? '', metadata);
+    const trimmedBody = trimStackBody(body);
+    const lines = [`${prefix} ${framing ?? ''}`];
+    if (fields)
+        lines.push(fields);
+    if (trimmedBody)
+        lines.push(trimmedBody);
+    return lines.join('\n');
+}
+function renderStructuredFields(framing, metadata) {
+    if (!metadata || Object.keys(metadata).length === 0)
+        return null;
+    // Drop fields that the message already encodes. We render framings and
+    // stacks into the message string itself in step executor / combined runtime, so
+    // repeating them here would be pure noise.
+    const redundant = new Set();
+    redundant.add('errorStack');
+    if (typeof metadata.errorMessage === 'string' &&
+        framing.includes(metadata.errorMessage)) {
+        redundant.add('errorMessage');
+    }
+    const wellKnown = new Set([
+        'workflowRunId',
+        'workflowName',
+        'stepId',
+        'stepName',
+        'errorAttribution',
+        'errorCode',
+        'errorName',
+        'errorMessage',
+        'errorStack',
+        'hint',
+        'attempt',
+        'retryCount',
+    ]);
+    const lines = [];
+    // Header: error class + attribution badge.
+    const errorName = pickString(metadata, 'errorName');
+    const attribution = pickString(metadata, 'errorAttribution');
+    if (errorName || attribution) {
+        const badge = attribution
+            ? attribution === 'sdk'
+                ? Ansi.magenta('sdk error')
+                : Ansi.red('user error')
+            : '';
+        const cls = errorName ? Ansi.bold(errorName) : '';
+        const sep = badge && cls ? Ansi.dim(' · ') : '';
+        lines.push(`  ${badge}${sep}${cls}`);
+    }
+    // ID + parsed friendly-name rows.
+    const runId = pickString(metadata, 'workflowRunId');
+    const wfName = pickString(metadata, 'workflowName');
+    if (runId) {
+        lines.push(formatIdRow('run', runId, wfName, formatWorkflowName));
+    }
+    else if (wfName) {
+        lines.push(formatIdRow('run', null, wfName, formatWorkflowName));
+    }
+    const stepId = pickString(metadata, 'stepId');
+    const stepName = pickString(metadata, 'stepName');
+    if (stepId || stepName) {
+        lines.push(formatIdRow('step', stepId, stepName, formatStepName));
+    }
+    if (metadata.attempt !== undefined || metadata.retryCount !== undefined) {
+        // `attempt` and `retryCount` read ambiguously next to each other (is
+        // "3 retries" the limit or what already happened?). Render the limit
+        // as "max retries" to make the boundary explicit, and keep `attempt`
+        // as the count of total invocations including the original.
+        const a = metadata.attempt;
+        const r = metadata.retryCount;
+        if (a !== undefined && r !== undefined) {
+            lines.push(`  ${kvKey('retry')} ${a} ${Ansi.dim('attempts ·')} ${r} ${Ansi.dim('max retries')}`);
+        }
+        else if (a !== undefined) {
+            lines.push(`  ${kvKey('retry')} ${a} ${Ansi.dim('attempts')}`);
+        }
+    }
+    const errorCode = pickString(metadata, 'errorCode');
+    if (errorCode && errorCode !== errorName) {
+        lines.push(`  ${kvKey('code')} ${Ansi.dim(errorCode)}`);
+    }
+    const hint = pickString(metadata, 'hint');
+    if (hint) {
+        lines.push(`  ${Ansi.hint(hint)}`);
+    }
+    // Sorted pass-through for unknown fields.
+    const passThrough = Object.entries(metadata)
+        .filter(([k, v]) => !wellKnown.has(k) && !redundant.has(k) && v !== undefined && v !== null)
+        .sort(([a], [b]) => a.localeCompare(b));
+    for (const [k, v] of passThrough) {
+        lines.push(`  ${kvKey(k)} ${formatPassthroughValue(v)}`);
+    }
+    return lines.length ? lines.join('\n') : null;
+}
+/**
+ * Strip the stack down to frames the user can act on. V8 stacks for our
+ * runtime errors look like:
+ *
+ *     Name: message
+ *         at userStep (./workflows/foo.ts:12:11)
+ *         at <unknown> (../../packages/core/src/runtime/step-executor.ts:535:32)
+ *         at <unknown> (.../node_modules/.pnpm/next@…/…/base-server.js:1454:9)
+ *         at <unknown> (.../node_modules/.pnpm/@opentelemetry+api@…/…/api.js:5440)
+ *         at … (15 more frames into Next.js / pnpm internals)
+ *
+ * Two-pass trim:
+ *
+ *   1. Drop framework-internal frames (`node_modules/.pnpm/`, `node:internal/`,
+ *      Turbopack-bundled `node_modules__pnpm_*` / `_next_dist_*` chunks).
+ *   2. Cap the surviving frames at `MAX_VISIBLE_FRAMES` — past that, even
+ *      "user-ish" frames are usually deep async wrapping that doesn't help
+ *      pinpoint the throw. The user can drop into the inspect CLI for the
+ *      full stack on demand.
+ *
+ * Each suppressed run emits one summary line so people know how much was
+ * trimmed.
+ */
+const MAX_VISIBLE_FRAMES = 6;
+function trimStackBody(body) {
+    if (!body)
+        return null;
+    const lines = body.split('\n');
+    const out = [];
+    let droppedRun = 0;
+    let visibleFrameCount = 0;
+    let cappedFrames = 0;
+    const flushDropped = () => {
+        if (droppedRun > 0) {
+            out.push(Ansi.dim(`        … ${droppedRun} more ${droppedRun === 1 ? 'frame' : 'frames'} in framework internals`));
+            droppedRun = 0;
+        }
+    };
+    for (const line of lines) {
+        const isFrame = line.trimStart().startsWith('at ');
+        if (isFrame && isFrameworkFrame(line)) {
+            droppedRun++;
+            continue;
+        }
+        if (isFrame && visibleFrameCount >= MAX_VISIBLE_FRAMES) {
+            cappedFrames++;
+            continue;
+        }
+        flushDropped();
+        out.push(line);
+        if (isFrame)
+            visibleFrameCount++;
+    }
+    flushDropped();
+    if (cappedFrames > 0) {
+        out.push(Ansi.dim(`        … ${cappedFrames} more ${cappedFrames === 1 ? 'frame' : 'frames'} (run \`pnpm wf inspect run <id>\` for the full stack)`));
+    }
+    return out.join('\n');
+}
+function isFrameworkFrame(line) {
+    // Only at-frames are candidates for stripping. Header lines (`Name: …`)
+    // and arbitrary trailing context (e.g. `code: 'USER_ERROR'`) pass through.
+    const trimmed = line.trimStart();
+    if (!trimmed.startsWith('at '))
+        return false;
+    // node:* internals (timers, async hooks, vm, etc.) never help users.
+    if (trimmed.includes('node:internal/'))
+        return true;
+    // pnpm-rooted frameworks installed as node_modules dependencies.
+    if (trimmed.includes('node_modules/.pnpm/'))
+        return true;
+    // Turbopack/Next bundle the same framework code into chunks like
+    // `node_modules__pnpm_<hash>._.js` and `<...>_next_dist_<hash>._.js`,
+    // and emits Next.js loader runtime as `0dx6_next_dist_<hash>._.js`.
+    // These are the frames that show up after Turbopack DCE — same intent
+    // as the raw `node_modules/.pnpm/` filter above.
+    if (trimmed.includes('node_modules__pnpm_'))
+        return true;
+    if (trimmed.includes('_next_dist_'))
+        return true;
+    // Plain node_modules (non-pnpm setups) for the same kinds of frameworks.
+    if (trimmed.includes('node_modules/next/') ||
+        trimmed.includes('node_modules/@opentelemetry/') ||
+        trimmed.includes('node_modules/vitest/') ||
+        trimmed.includes('node_modules/@vitest/')) {
+        return true;
+    }
+    return false;
+}
+function pickString(metadata, key) {
+    const v = metadata[key];
+    return typeof v === 'string' && v.length > 0 ? v : null;
+}
+function kvKey(key) {
+    return Ansi.dim(key.padEnd(6));
+}
+function formatIdRow(label, id, name, formatName) {
+    const idCell = id ? id : Ansi.dim('—');
+    const parsed = name
+        ? label === 'run'
+            ? parseWorkflowName(name)
+            : parseStepName(name)
+        : null;
+    const nameCell = parsed
+        ? `${Ansi.dim('·')} ${formatName(name)}`
+        : '';
+    return `  ${kvKey(label)} ${idCell}${nameCell ? ' ' + nameCell : ''}`;
+}
+function formatPassthroughValue(v) {
+    if (typeof v === 'string') {
+        if (v.includes('\n')) {
+            return v
+                .split('\n')
+                .map((line, i) => (i === 0 ? line : `         ${line}`))
+                .join('\n');
+        }
+        return v;
+    }
+    if (typeof v === 'number' || typeof v === 'boolean')
+        return String(v);
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"log-format.js","sourceRoot":"","sources":["../src/log-format.ts"],"names":[],"mappings":"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","sourcesContent":["import * as Ansi from '@workflow/errors/ansi';\nimport {\n  formatStepName,\n  formatWorkflowName,\n  parseStepName,\n  parseWorkflowName,\n} from '@workflow/utils';\n\n/**\n * Structured-log composition for `console.error` / `console.warn`. Emits\n * one string in three sections so the most useful information is at the\n * top, stack trace at the bottom:\n *\n *     [workflow-sdk] <framing line>\n *       user error · FatalError\n *       run    wrun_…\n *       step   step_… · add (./workflows/x)\n *       hint:  Move the call to a step function.\n *     FatalError: …\n *         at … (trimmed stack — internals collapsed)\n *\n * Without this composition, callers passing `${framing}\\n${stack}` as the\n * message and structured fields as the metadata object got `util.inspect`'s\n * default object dump appended *after* the stack, which buries the run ID\n * and attribution badge under 30+ lines of `node_modules/.pnpm/...` frames.\n *\n * The same metadata is also emitted as structured OTel span events from\n * the logger itself, so backends that want JSON-shaped data still get it.\n * web/web-shared do not consume stderr at all — they read CBOR/JSON event\n * payloads from the World event log.\n */\nexport function composeLogLine(\n  prefix: string,\n  message: string,\n  metadata: Record<string, unknown> | undefined\n): string {\n  const [framing, ...rest] = message.split('\\n');\n  const body = rest.join('\\n');\n  const fields = renderStructuredFields(framing ?? '', metadata);\n  const trimmedBody = trimStackBody(body);\n\n  const lines: string[] = [`${prefix} ${framing ?? ''}`];\n  if (fields) lines.push(fields);\n  if (trimmedBody) lines.push(trimmedBody);\n  return lines.join('\\n');\n}\n\nfunction renderStructuredFields(\n  framing: string,\n  metadata: Record<string, unknown> | undefined\n): string | null {\n  if (!metadata || Object.keys(metadata).length === 0) return null;\n\n  // Drop fields that the message already encodes. We render framings and\n  // stacks into the message string itself in step executor / combined runtime, so\n  // repeating them here would be pure noise.\n  const redundant = new Set<string>();\n  redundant.add('errorStack');\n  if (\n    typeof metadata.errorMessage === 'string' &&\n    framing.includes(metadata.errorMessage as string)\n  ) {\n    redundant.add('errorMessage');\n  }\n\n  const wellKnown = new Set([\n    'workflowRunId',\n    'workflowName',\n    'stepId',\n    'stepName',\n    'errorAttribution',\n    'errorCode',\n    'errorName',\n    'errorMessage',\n    'errorStack',\n    'hint',\n    'attempt',\n    'retryCount',\n  ]);\n\n  const lines: string[] = [];\n\n  // Header: error class + attribution badge.\n  const errorName = pickString(metadata, 'errorName');\n  const attribution = pickString(metadata, 'errorAttribution');\n  if (errorName || attribution) {\n    const badge = attribution\n      ? attribution === 'sdk'\n        ? Ansi.magenta('sdk error')\n        : Ansi.red('user error')\n      : '';\n    const cls = errorName ? Ansi.bold(errorName) : '';\n    const sep = badge && cls ? Ansi.dim(' · ') : '';\n    lines.push(`  ${badge}${sep}${cls}`);\n  }\n\n  // ID + parsed friendly-name rows.\n  const runId = pickString(metadata, 'workflowRunId');\n  const wfName = pickString(metadata, 'workflowName');\n  if (runId) {\n    lines.push(formatIdRow('run', runId, wfName, formatWorkflowName));\n  } else if (wfName) {\n    lines.push(formatIdRow('run', null, wfName, formatWorkflowName));\n  }\n\n  const stepId = pickString(metadata, 'stepId');\n  const stepName = pickString(metadata, 'stepName');\n  if (stepId || stepName) {\n    lines.push(formatIdRow('step', stepId, stepName, formatStepName));\n  }\n\n  if (metadata.attempt !== undefined || metadata.retryCount !== undefined) {\n    // `attempt` and `retryCount` read ambiguously next to each other (is\n    // \"3 retries\" the limit or what already happened?). Render the limit\n    // as \"max retries\" to make the boundary explicit, and keep `attempt`\n    // as the count of total invocations including the original.\n    const a = metadata.attempt;\n    const r = metadata.retryCount;\n    if (a !== undefined && r !== undefined) {\n      lines.push(\n        `  ${kvKey('retry')} ${a} ${Ansi.dim('attempts ·')} ${r} ${Ansi.dim('max retries')}`\n      );\n    } else if (a !== undefined) {\n      lines.push(`  ${kvKey('retry')} ${a} ${Ansi.dim('attempts')}`);\n    }\n  }\n\n  const errorCode = pickString(metadata, 'errorCode');\n  if (errorCode && errorCode !== errorName) {\n    lines.push(`  ${kvKey('code')} ${Ansi.dim(errorCode)}`);\n  }\n\n  const hint = pickString(metadata, 'hint');\n  if (hint) {\n    lines.push(`  ${Ansi.hint(hint)}`);\n  }\n\n  // Sorted pass-through for unknown fields.\n  const passThrough = Object.entries(metadata)\n    .filter(\n      ([k, v]) =>\n        !wellKnown.has(k) && !redundant.has(k) && v !== undefined && v !== null\n    )\n    .sort(([a], [b]) => a.localeCompare(b));\n  for (const [k, v] of passThrough) {\n    lines.push(`  ${kvKey(k)} ${formatPassthroughValue(v)}`);\n  }\n\n  return lines.length ? lines.join('\\n') : null;\n}\n\n/**\n * Strip the stack down to frames the user can act on. V8 stacks for our\n * runtime errors look like:\n *\n *     Name: message\n *         at userStep (./workflows/foo.ts:12:11)\n *         at <unknown> (../../packages/core/src/runtime/step-executor.ts:535:32)\n *         at <unknown> (.../node_modules/.pnpm/next@…/…/base-server.js:1454:9)\n *         at <unknown> (.../node_modules/.pnpm/@opentelemetry+api@…/…/api.js:5440)\n *         at … (15 more frames into Next.js / pnpm internals)\n *\n * Two-pass trim:\n *\n *   1. Drop framework-internal frames (`node_modules/.pnpm/`, `node:internal/`,\n *      Turbopack-bundled `node_modules__pnpm_*` / `_next_dist_*` chunks).\n *   2. Cap the surviving frames at `MAX_VISIBLE_FRAMES` — past that, even\n *      \"user-ish\" frames are usually deep async wrapping that doesn't help\n *      pinpoint the throw. The user can drop into the inspect CLI for the\n *      full stack on demand.\n *\n * Each suppressed run emits one summary line so people know how much was\n * trimmed.\n */\nconst MAX_VISIBLE_FRAMES = 6;\n\nfunction trimStackBody(body: string): string | null {\n  if (!body) return null;\n  const lines = body.split('\\n');\n  const out: string[] = [];\n  let droppedRun = 0;\n  let visibleFrameCount = 0;\n  let cappedFrames = 0;\n\n  const flushDropped = () => {\n    if (droppedRun > 0) {\n      out.push(\n        Ansi.dim(\n          `        … ${droppedRun} more ${droppedRun === 1 ? 'frame' : 'frames'} in framework internals`\n        )\n      );\n      droppedRun = 0;\n    }\n  };\n\n  for (const line of lines) {\n    const isFrame = line.trimStart().startsWith('at ');\n    if (isFrame && isFrameworkFrame(line)) {\n      droppedRun++;\n      continue;\n    }\n    if (isFrame && visibleFrameCount >= MAX_VISIBLE_FRAMES) {\n      cappedFrames++;\n      continue;\n    }\n    flushDropped();\n    out.push(line);\n    if (isFrame) visibleFrameCount++;\n  }\n  flushDropped();\n  if (cappedFrames > 0) {\n    out.push(\n      Ansi.dim(\n        `        … ${cappedFrames} more ${cappedFrames === 1 ? 'frame' : 'frames'} (run \\`pnpm wf inspect run <id>\\` for the full stack)`\n      )\n    );\n  }\n  return out.join('\\n');\n}\n\nfunction isFrameworkFrame(line: string): boolean {\n  // Only at-frames are candidates for stripping. Header lines (`Name: …`)\n  // and arbitrary trailing context (e.g. `code: 'USER_ERROR'`) pass through.\n  const trimmed = line.trimStart();\n  if (!trimmed.startsWith('at ')) return false;\n  // node:* internals (timers, async hooks, vm, etc.) never help users.\n  if (trimmed.includes('node:internal/')) return true;\n  // pnpm-rooted frameworks installed as node_modules dependencies.\n  if (trimmed.includes('node_modules/.pnpm/')) return true;\n  // Turbopack/Next bundle the same framework code into chunks like\n  // `node_modules__pnpm_<hash>._.js` and `<...>_next_dist_<hash>._.js`,\n  // and emits Next.js loader runtime as `0dx6_next_dist_<hash>._.js`.\n  // These are the frames that show up after Turbopack DCE — same intent\n  // as the raw `node_modules/.pnpm/` filter above.\n  if (trimmed.includes('node_modules__pnpm_')) return true;\n  if (trimmed.includes('_next_dist_')) return true;\n  // Plain node_modules (non-pnpm setups) for the same kinds of frameworks.\n  if (\n    trimmed.includes('node_modules/next/') ||\n    trimmed.includes('node_modules/@opentelemetry/') ||\n    trimmed.includes('node_modules/vitest/') ||\n    trimmed.includes('node_modules/@vitest/')\n  ) {\n    return true;\n  }\n  return false;\n}\n\nfunction pickString(\n  metadata: Record<string, unknown>,\n  key: string\n): string | null {\n  const v = metadata[key];\n  return typeof v === 'string' && v.length > 0 ? v : null;\n}\n\nfunction kvKey(key: string): string {\n  return Ansi.dim(key.padEnd(6));\n}\n\nfunction formatIdRow(\n  label: string,\n  id: string | null,\n  name: string | null,\n  formatName: (n: string) => string\n): string {\n  const idCell = id ? id : Ansi.dim('—');\n  const parsed = name\n    ? label === 'run'\n      ? parseWorkflowName(name)\n      : parseStepName(name)\n    : null;\n  const nameCell = parsed\n    ? `${Ansi.dim('·')} ${formatName(name as string)}`\n    : '';\n  return `  ${kvKey(label)} ${idCell}${nameCell ? ' ' + nameCell : ''}`;\n}\n\nfunction formatPassthroughValue(v: unknown): string {\n  if (typeof v === 'string') {\n    if (v.includes('\\n')) {\n      return v\n        .split('\\n')\n        .map((line, i) => (i === 0 ? line : `         ${line}`))\n        .join('\\n');\n    }\n    return v;\n  }\n  if (typeof v === 'number' || typeof v === 'boolean') return String(v);\n  try {\n    return JSON.stringify(v);\n  } catch {\n    return String(v);\n  }\n}\n"]}

package/dist/logger.d.ts

@@ -1,31 +1,30 @@
-export declare const stepLogger: {
-    debug: (message: string, metadata?: Record<string, any>) => void;
-    info: (message: string, metadata?: Record<string, any>) => void;
-    warn: (message: string, metadata?: Record<string, any>) => void;
-    error: (message: string, metadata?: Record<string, any>) => void;
-};
-export declare const runtimeLogger: {
-    debug: (message: string, metadata?: Record<string, any>) => void;
-    info: (message: string, metadata?: Record<string, any>) => void;
-    warn: (message: string, metadata?: Record<string, any>) => void;
-    error: (message: string, metadata?: Record<string, any>) => void;
-};
-export declare const webhookLogger: {
-    debug: (message: string, metadata?: Record<string, any>) => void;
-    info: (message: string, metadata?: Record<string, any>) => void;
-    warn: (message: string, metadata?: Record<string, any>) => void;
-    error: (message: string, metadata?: Record<string, any>) => void;
-};
-export declare const eventsLogger: {
-    debug: (message: string, metadata?: Record<string, any>) => void;
-    info: (message: string, metadata?: Record<string, any>) => void;
-    warn: (message: string, metadata?: Record<string, any>) => void;
-    error: (message: string, metadata?: Record<string, any>) => void;
-};
-export declare const adapterLogger: {
-    debug: (message: string, metadata?: Record<string, any>) => void;
-    info: (message: string, metadata?: Record<string, any>) => void;
-    warn: (message: string, metadata?: Record<string, any>) => void;
-    error: (message: string, metadata?: Record<string, any>) => void;
-};
+type LogMetadata = Record<string, unknown>;
+type LogFn = (message: string, metadata?: LogMetadata) => void;
+export interface Logger {
+    debug: LogFn;
+    info: LogFn;
+    warn: LogFn;
+    error: LogFn;
+    /**
+     * Returns a child logger that merges the given metadata into every call.
+     * Useful for attaching stable context (e.g. `workflowRunId`, `workflowName`,
+     * `stepId`) so callers don't have to repeat it on every log.
+     *
+     * Call-site metadata wins on conflict, so children can still override.
+     */
+    child: (metadata: LogMetadata) => Logger;
+    /**
+     * Convenience child logger for a workflow run. Equivalent to
+     * `logger.child({ workflowRunId, workflowName })`, but centralized so all
+     * runtime code structures run metadata consistently.
+     */
+    forRun: (workflowRunId: string, workflowName?: string, extra?: LogMetadata) => Logger;
+}
+export declare const stepLogger: Logger;
+export declare const runtimeLogger: Logger;
+export declare const webhookLogger: Logger;
+export declare const eventsLogger: Logger;
+export declare const adapterLogger: Logger;
+export declare const buildLogger: Logger;
+export {};
 //# sourceMappingURL=logger.d.ts.map

package/dist/logger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAyCA,eAAO,MAAM,UAAU;qBAhCF,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAgCb,CAAC;AAC/C,eAAO,MAAM,aAAa;qBAjCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAiCP,CAAC;AACrD,eAAO,MAAM,aAAa;qBAlCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAkCP,CAAC;AACrD,eAAO,MAAM,YAAY;qBAnCJ,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAmCT,CAAC;AACnD,eAAO,MAAM,aAAa;qBApCL,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;oBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;qBAAtC,MAAM,aAAa,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;CAoCP,CAAC"}
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../src/logger.ts"],"names":[],"mappings":"AAGA,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAE3C,KAAK,KAAK,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,KAAK,IAAI,CAAC;AAE/D,MAAM,WAAW,MAAM;IACrB,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,KAAK,CAAC;IACZ,IAAI,EAAE,KAAK,CAAC;IACZ,KAAK,EAAE,KAAK,CAAC;IACb;;;;;;OAMG;IACH,KAAK,EAAE,CAAC,QAAQ,EAAE,WAAW,KAAK,MAAM,CAAC;IACzC;;;;OAIG;IACH,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,YAAY,CAAC,EAAE,MAAM,EACrB,KAAK,CAAC,EAAE,WAAW,KAChB,MAAM,CAAC;CACb;AA8GD,eAAO,MAAM,UAAU,QAAuB,CAAC;AAC/C,eAAO,MAAM,aAAa,QAA0B,CAAC;AACrD,eAAO,MAAM,aAAa,QAA0B,CAAC;AACrD,eAAO,MAAM,YAAY,QAAyB,CAAC;AACnD,eAAO,MAAM,aAAa,QAA0B,CAAC;AACrD,eAAO,MAAM,WAAW,QAEtB,CAAC"}