@workflow/core 5.0.0-beta.5 → 5.0.0-beta.51

package/dist/telemetry.d.ts

@@ -1,5 +1,59 @@
 import type * as api from '@opentelemetry/api';
 import type { Span, SpanKind, SpanOptions } from '@opentelemetry/api';
+import { WorkflowSuspension } from './global.js';
+/**
+ * Controls how workflow/step queue-handler spans relate to the run-origin
+ * trace context carried in queue messages:
+ *
+ * - `'linked'` (default): each invocation starts a NEW root trace; the
+ *   run-origin context (and the incoming delivery context) are attached as
+ *   span links. This keeps traces bounded per invocation instead of
+ *   stitching a long-lived run into one giant trace.
+ * - `'continuous'`: the restored run-origin context becomes the parent of
+ *   the invocation span (legacy behavior), producing a single trace that
+ *   spans the entire run.
+ */
+export type WorkflowTraceMode = 'linked' | 'continuous';
+/**
+ * Resolves the active trace mode from the `WORKFLOW_TRACE_MODE` env var.
+ * Defaults to `'linked'`; any value other than `'continuous'` selects it.
+ * Unrecognized non-empty values (e.g. typos like `continous`) emit a
+ * one-time warning so silent fallback to `linked` is at least visible.
+ */
+export declare function getWorkflowTraceMode(): WorkflowTraceMode;
+/**
+ * Returns whether a serialized trace carrier is usable, i.e. present and
+ * non-empty. `serializeTraceCarrier()` returns `{}` when no OTEL SDK is
+ * registered or no span is active, and `start()` always attaches the
+ * carrier to the first queue message, so an empty carrier must be treated
+ * the same as an absent one wherever the trace-mode logic branches.
+ */
+export declare function isUsableTraceCarrier(carrier: Record<string, string> | undefined): carrier is Record<string, string>;
+/**
+ * Returns the trace carrier to attach to messages the current invocation
+ * enqueues. In `linked` mode the ORIGINAL run-origin carrier is forwarded
+ * unchanged (when usable) so every future invocation links back to the same
+ * origin; otherwise (`continuous` mode, or no usable incoming carrier)
+ * the current (active) context is serialized, so the trace keeps chaining
+ * (continuous) or the first instrumented invocation becomes the de-facto
+ * origin (linked).
+ */
+export declare function getNextTraceCarrier(traceMode: WorkflowTraceMode, incomingCarrier: Record<string, string> | undefined): Promise<Record<string, string>>;
+/**
+ * Builds the span links for a queue-delivered invocation span
+ * (`workflow.execute` / `step.execute`):
+ *
+ * - In `linked` mode the invocation span is a CHILD of the local delivery
+ *   (flow-route) context, so the only link is to the run-origin context
+ *   from the message's trace carrier, connecting this bounded per-invocation
+ *   trace back to where the run was started. The run-origin context is a
+ *   link, never a parent, and re-enqueues forward the original carrier
+ *   unchanged, so the whole run is never stitched into one giant trace.
+ *   The link is skipped when the carrier is absent, empty, or invalid.
+ * - In `continuous` mode the run-origin context is restored as the parent
+ *   instead, and the link points at the incoming delivery context.
+ */
+export declare function buildInvocationSpanLinks(traceMode: WorkflowTraceMode, incomingCarrier: Record<string, string> | undefined): Promise<api.Link[] | undefined>;
 /**
  * Serializes the current trace context into a format that can be passed through queues
  * @returns A record of strings representing the trace context
@@ -19,6 +73,36 @@ export declare function deserializeTraceCarrier(traceCarrier: Record<string, str
  */
 export declare function withTraceContext<T>(traceCarrier: Record<string, string> | undefined, fn: () => Promise<T>): Promise<T>;
 export declare function trace<T>(spanName: string, ...args: [fn: (span?: Span) => Promise<T>] | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]): Promise<T>;
+/** Starts a child span without installing it as the active context. */
+export declare function startTraceSpan(spanName: string): Promise<{
+    end: () => void;
+    fail: (error: unknown) => void;
+}>;
+/** Bind work to the currently active span even when it starts from a child. */
+export declare function bindActiveTraceContext<Args extends unknown[], Result>(fn: (...args: Args) => Result): Promise<(...args: Args) => Result>;
+/** Keeps a parked workflow's ambient trace context aligned with each resume. */
+export declare function createRefreshableTraceContext(): Promise<{
+    refresh(): void;
+    run: <T>(fn: () => T) => T;
+}>;
+/**
+ * Emit a span whose start is back-dated to `startEpochMs` and whose end is now,
+ * so its duration reflects an interval only measurable at its end (e.g.
+ * time-to-first-chunk, known when the first chunk arrives). Unlike `trace()`,
+ * this records an already-elapsed span in one shot rather than wrapping a
+ * callback. No-op when OpenTelemetry is not available.
+ */
+export declare function recordElapsedSpan(spanName: string, startEpochMs: number, opts?: SpanOptions): Promise<void>;
+/**
+ * Records the same user-code interval as the inner `step.execute` span. The
+ * configured OpenTelemetry meter provider attaches resource dimensions such as
+ * service.name, so this avoids accepting a caller-controlled service tag.
+ */
+export declare function recordStepExecutionDuration(durationMs: number, status: 'ok' | 'error'): Promise<void>;
+/**
+ * Applies the workflow suspension algebraic effect to an active span.
+ */
+export declare function applyWorkflowSuspensionToSpan(error: WorkflowSuspension, span: api.Span): void;
 export declare function getSpanContextForTraceCarrier(carrier: Record<string, string>): Promise<api.SpanContext | undefined>;
 export declare function getActiveSpan(): Promise<api.Span | undefined>;
 /**
@@ -31,6 +115,13 @@ export declare function instrumentObject<T extends object>(prefix: string, o: T)
 export declare function getSpanKind(field: keyof typeof SpanKind): Promise<api.SpanKind | undefined>;
 export declare function withOtel<T>(fn: (otel: typeof api) => T): Promise<Awaited<T> | undefined>;
 export declare function linkToCurrentContext(): Promise<[api.Link] | undefined>;
+/**
+ * Builds a span link pointing at the span context embedded in a serialized
+ * trace carrier (e.g. the run-origin context flowing through queue
+ * messages). Returns `undefined` when OTEL is unavailable, the carrier is
+ * absent, or it does not contain a valid span context.
+ */
+export declare function linkToTraceCarrier(carrier: Record<string, string> | undefined): Promise<api.Link | undefined>;
 /**
  * Workflow context to propagate via baggage
  */

package/dist/telemetry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,oBAAoB,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAUtE;;;GAGG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAO7E;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,CAC3C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,oCAMrC;AAED;;;;;GAKG;AACH,wBAAsB,gBAAgB,CAAC,CAAC,EACtC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EAChD,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAcZ;AAiBD,wBAAsB,KAAK,CAAC,CAAC,EAC3B,QAAQ,EAAE,MAAM,EAChB,GAAG,IAAI,EACH,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACjC,CAAC,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EAAE,IAAI,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC,GACvD,OAAO,CAAC,CAAC,CAAC,CA4BZ;AAwBD,wBAAsB,6BAA6B,CACjD,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,wCAQhC;AAED,wBAAsB,aAAa,kCAElC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,CAa1E;AAED,wBAAsB,WAAW,CAAC,KAAK,EAAE,MAAM,OAAO,QAAQ,qCAE7D;AAED,wBAAsB,QAAQ,CAAC,CAAC,EAC9B,EAAE,EAAE,CAAC,IAAI,EAAE,OAAO,GAAG,KAAK,CAAC,GAC1B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAIjC;AAED,wBAAgB,oBAAoB,IAAI,OAAO,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,CAMtE;AAMD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,CAAC,EACzC,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAiBZ;AAED;;;GAGG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CACjD,sBAAsB,GAAG,SAAS,CACnC,CAgBA"}
+{"version":3,"file":"telemetry.d.ts","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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"}

package/dist/telemetry.js

@@ -1,10 +1,75 @@
-import { once } from '@workflow/utils';
+import { globalSingleton, once } from '@workflow/utils';
 import { WorkflowSuspension } from './global.js';
 import { runtimeLogger } from './logger.js';
 import * as Attr from './telemetry/semantic-conventions.js';
-// ============================================================
-// Trace Context Propagation Utilities
-// ============================================================
+/**
+ * Unrecognized `WORKFLOW_TRACE_MODE` values we already warned about. On
+ * `globalThis` (see `globalSingleton`) so the warning stays once per process
+ * rather than once per bundler layer.
+ */
+const traceModeWarnings = globalSingleton('@workflow/core//traceModeWarnings', 1, () => ({ unrecognized: new Set() }));
+/**
+ * Resolves the active trace mode from the `WORKFLOW_TRACE_MODE` env var.
+ * Defaults to `'linked'`; any value other than `'continuous'` selects it.
+ * Unrecognized non-empty values (e.g. typos like `continous`) emit a
+ * one-time warning so silent fallback to `linked` is at least visible.
+ */
+export function getWorkflowTraceMode() {
+    const value = process.env.WORKFLOW_TRACE_MODE;
+    if (value === 'continuous')
+        return 'continuous';
+    if (value &&
+        value !== 'linked' &&
+        !traceModeWarnings.unrecognized.has(value)) {
+        traceModeWarnings.unrecognized.add(value);
+        runtimeLogger.warn(`Unrecognized WORKFLOW_TRACE_MODE value "${value}"; expected "linked" or "continuous". Falling back to "linked".`);
+    }
+    return 'linked';
+}
+/**
+ * Returns whether a serialized trace carrier is usable, i.e. present and
+ * non-empty. `serializeTraceCarrier()` returns `{}` when no OTEL SDK is
+ * registered or no span is active, and `start()` always attaches the
+ * carrier to the first queue message, so an empty carrier must be treated
+ * the same as an absent one wherever the trace-mode logic branches.
+ */
+export function isUsableTraceCarrier(carrier) {
+    return carrier !== undefined && Object.keys(carrier).length > 0;
+}
+/**
+ * Returns the trace carrier to attach to messages the current invocation
+ * enqueues. In `linked` mode the ORIGINAL run-origin carrier is forwarded
+ * unchanged (when usable) so every future invocation links back to the same
+ * origin; otherwise (`continuous` mode, or no usable incoming carrier)
+ * the current (active) context is serialized, so the trace keeps chaining
+ * (continuous) or the first instrumented invocation becomes the de-facto
+ * origin (linked).
+ */
+export function getNextTraceCarrier(traceMode, incomingCarrier) {
+    return traceMode === 'linked' && isUsableTraceCarrier(incomingCarrier)
+        ? Promise.resolve(incomingCarrier)
+        : serializeTraceCarrier();
+}
+/**
+ * Builds the span links for a queue-delivered invocation span
+ * (`workflow.execute` / `step.execute`):
+ *
+ * - In `linked` mode the invocation span is a CHILD of the local delivery
+ *   (flow-route) context, so the only link is to the run-origin context
+ *   from the message's trace carrier, connecting this bounded per-invocation
+ *   trace back to where the run was started. The run-origin context is a
+ *   link, never a parent, and re-enqueues forward the original carrier
+ *   unchanged, so the whole run is never stitched into one giant trace.
+ *   The link is skipped when the carrier is absent, empty, or invalid.
+ * - In `continuous` mode the run-origin context is restored as the parent
+ *   instead, and the link points at the incoming delivery context.
+ */
+export async function buildInvocationSpanLinks(traceMode, incomingCarrier) {
+    if (traceMode !== 'linked')
+        return linkToCurrentContext();
+    const originLink = await linkToTraceCarrier(isUsableTraceCarrier(incomingCarrier) ? incomingCarrier : undefined);
+    return originLink ? [originLink] : undefined;
+}
 /**
  * Serializes the current trace context into a format that can be passed through queues
  * @returns A record of strings representing the trace context
@@ -50,6 +115,17 @@ export async function withTraceContext(traceCarrier, fn) {
     return otel.context.with(extractedContext, async () => await fn());
 }
 const OtelApi = once(async () => {
+    // `@opentelemetry/api` is an optional peer dependency. The static specifier
+    // is intentional: esbuild-bundled targets (the CLI's
+    // `vercel-build-output-api` build, Nitro, Astro) ship a self-contained
+    // bundle with no node_modules, so the package must be *inlined* at build
+    // time for spans to work at runtime; a runtime-built specifier is opaque to
+    // esbuild and would silently disable tracing there. Bundlers that reject an
+    // unresolvable static `import()` when the peer isn't installed (Rollup/Vite,
+    // e.g. SvelteKit) instead externalize `@opentelemetry/api` in the workflow
+    // framework integration, which keeps the build green and still loads real
+    // OTel when the peer is present. Runtime semantics: present → loaded, absent
+    // → caught and tracing disabled.
     try {
         return await import('@opentelemetry/api');
     }
@@ -62,8 +138,72 @@ const Tracer = once(async () => {
     const api = await OtelApi.value;
     if (!api)
         return null;
-    return api.trace.getTracer('workflow');
+    const tracer = api.trace.getTracer('workflow');
+    logOtelDiagnosticOnce(api, tracer);
+    return tracer;
 });
+const StepExecutionDurationHistogram = once(async () => {
+    const otel = await OtelApi.value;
+    if (!otel)
+        return null;
+    // service.name is a resource attribute, applied by the configured provider.
+    return otel.metrics
+        .getMeter('workflow')
+        .createHistogram('workflow.step.execute.duration', {
+        description: 'Duration of user step execution',
+        unit: 'ms',
+    });
+});
+/**
+ * One-shot runtime diagnostic (DEBUG=workflow:* only), same shape as the one
+ * world-vercel emits tagged `world-vercel`: prints how this module instance
+ * of `@opentelemetry/api` sees the global registration, so a deployment's
+ * logs show the two packages' views side by side.
+ */
+// per-copy-ok: this diagnostic reports how THIS module instance sees the global
+// OTel registration, which is the whole point of the log. With several copies
+// in a process, each one's view is what is worth seeing.
+let otelDiagLogged = false;
+function describeThrownValue(value) {
+    try {
+        if (typeof value === 'object' &&
+            value !== null &&
+            'message' in value &&
+            typeof value.message === 'string') {
+            return value.message;
+        }
+        return String(value);
+    }
+    catch {
+        return 'Unknown error';
+    }
+}
+function logOtelDiagnosticOnce(otel, tracer) {
+    const debugEnabled = typeof process !== 'undefined' &&
+        typeof process.env.DEBUG === 'string' &&
+        (process.env.DEBUG.includes('workflow:') || process.env.DEBUG === '*');
+    if (otelDiagLogged || !debugEnabled)
+        return;
+    otelDiagLogged = true;
+    try {
+        const g = globalThis[Symbol.for('opentelemetry.js.api.1')];
+        const provider = otel.trace.getTracerProvider();
+        const delegate = provider.getDelegate?.() ?? provider;
+        const probe = tracer.startSpan('workflow.otel.probe.core');
+        console.warn('[workflow:otel-diag] core', JSON.stringify({
+            globalRegistrationVersion: g?.version ?? null,
+            providerCtor: provider?.constructor?.name ?? null,
+            delegateCtor: delegate?.constructor?.name ?? null,
+            tracerCtor: tracer?.constructor?.name ?? null,
+            probeCtor: probe?.constructor?.name ?? null,
+            probeRecording: probe.isRecording(),
+        }));
+        probe.end();
+    }
+    catch (error) {
+        console.warn('[workflow:otel-diag] core failed:', error instanceof Error ? error.message : error);
+    }
+}
 export async function trace(spanName, ...args) {
     const [tracer, otel] = await Promise.all([Tracer.value, OtelApi.value]);
     const { fn, opts } = typeof args[0] === 'function'
@@ -81,11 +221,16 @@ export async function trace(spanName, ...args) {
             return result;
         }
         catch (e) {
-            span.setStatus({
-                code: otel.SpanStatusCode.ERROR,
-                message: e.message,
-            });
-            applyWorkflowSuspensionToSpan(e, otel, span);
+            if (WorkflowSuspension.is(e)) {
+                span.setStatus({ code: otel.SpanStatusCode.OK });
+                applyWorkflowSuspensionToSpan(e, span);
+            }
+            else {
+                span.setStatus({
+                    code: otel.SpanStatusCode.ERROR,
+                    message: describeThrownValue(e),
+                });
+            }
             throw e;
         }
         finally {
@@ -93,15 +238,78 @@ export async function trace(spanName, ...args) {
         }
     });
 }
+/** Starts a child span without installing it as the active context. */
+export async function startTraceSpan(spanName) {
+    const [tracer, otel] = await Promise.all([Tracer.value, OtelApi.value]);
+    if (!tracer || !otel)
+        return { end() { }, fail() { } };
+    const span = tracer.startSpan(spanName);
+    let ended = false;
+    const finish = (status) => {
+        if (ended)
+            return;
+        ended = true;
+        span.setStatus(status);
+        span.end();
+    };
+    return {
+        end: () => finish({ code: otel.SpanStatusCode.OK }),
+        fail: (error) => finish({
+            code: otel.SpanStatusCode.ERROR,
+            message: describeThrownValue(error),
+        }),
+    };
+}
+/** Bind work to the currently active span even when it starts from a child. */
+export async function bindActiveTraceContext(fn) {
+    const otel = await OtelApi.value;
+    return otel ? otel.context.bind(otel.context.active(), fn) : fn;
+}
+/** Keeps a parked workflow's ambient trace context aligned with each resume. */
+export async function createRefreshableTraceContext() {
+    const otel = await OtelApi.value;
+    if (!otel) {
+        return { refresh() { }, run: (fn) => fn() };
+    }
+    let current = otel.context.active();
+    const context = {
+        getValue: (key) => current.getValue(key),
+        setValue: (key, value) => current.setValue(key, value),
+        deleteValue: (key) => current.deleteValue(key),
+    };
+    return {
+        refresh: () => {
+            current = otel.context.active();
+        },
+        run: (fn) => otel.context.with(context, fn),
+    };
+}
 /**
- * Applies workflow suspension attributes to the given span if the error is a WorkflowSuspension
- * which is technically not an error, but an algebraic effect indicating suspension.
+ * Emit a span whose start is back-dated to `startEpochMs` and whose end is now,
+ * so its duration reflects an interval only measurable at its end (e.g.
+ * time-to-first-chunk, known when the first chunk arrives). Unlike `trace()`,
+ * this records an already-elapsed span in one shot rather than wrapping a
+ * callback. No-op when OpenTelemetry is not available.
  */
-function applyWorkflowSuspensionToSpan(error, otel, span) {
-    if (!error || !WorkflowSuspension.is(error)) {
+export async function recordElapsedSpan(spanName, startEpochMs, opts) {
+    const tracer = await Tracer.value;
+    if (!tracer)
         return;
-    }
-    span.setStatus({ code: otel.SpanStatusCode.OK });
+    tracer.startSpan(spanName, { ...opts, startTime: startEpochMs }).end();
+}
+/**
+ * Records the same user-code interval as the inner `step.execute` span. The
+ * configured OpenTelemetry meter provider attaches resource dimensions such as
+ * service.name, so this avoids accepting a caller-controlled service tag.
+ */
+export async function recordStepExecutionDuration(durationMs, status) {
+    const histogram = await StepExecutionDurationHistogram.value;
+    histogram?.record(durationMs, { 'workflow.step.status': status });
+}
+/**
+ * Applies the workflow suspension algebraic effect to an active span.
+ */
+export function applyWorkflowSuspensionToSpan(error, span) {
     span.setAttributes({
         ...Attr.WorkflowSuspensionState('suspended'),
         ...Attr.WorkflowSuspensionStepCount(error.stepCount),
@@ -158,6 +366,25 @@ export function linkToCurrentContext() {
         return [{ context }];
     });
 }
+/**
+ * Builds a span link pointing at the span context embedded in a serialized
+ * trace carrier (e.g. the run-origin context flowing through queue
+ * messages). Returns `undefined` when OTEL is unavailable, the carrier is
+ * absent, or it does not contain a valid span context.
+ */
+export async function linkToTraceCarrier(carrier) {
+    if (!carrier)
+        return;
+    const [context, otel] = await Promise.all([
+        getSpanContextForTraceCarrier(carrier),
+        OtelApi.value,
+    ]);
+    if (!context || !otel)
+        return;
+    if (!otel.trace.isSpanContextValid(context))
+        return;
+    return { context };
+}
 /**
  * Sets workflow context as OTEL baggage for automatic propagation.
  * Baggage is propagated across service boundaries via HTTP headers.
@@ -197,4 +424,4 @@ export async function getWorkflowBaggage() {
         workflowName: name,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as api from '@opentelemetry/api';\nimport type { Span, SpanKind, SpanOptions } from '@opentelemetry/api';\nimport { once } from '@workflow/utils';\nimport { WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport * as Attr from './telemetry/semantic-conventions.js';\n\n// ============================================================\n// Trace Context Propagation Utilities\n// ============================================================\n\n/**\n * Serializes the current trace context into a format that can be passed through queues\n * @returns A record of strings representing the trace context\n */\nexport async function serializeTraceCarrier(): Promise<Record<string, string>> {\n  const otel = await OtelApi.value;\n  if (!otel) return {};\n  const carrier: Record<string, string> = {};\n  // Inject the current context into the carrier\n  otel.propagation.inject(otel.context.active(), carrier);\n  return carrier;\n}\n\n/**\n * Deserializes trace context and returns a context that can be used to continue the trace\n * @param traceCarrier The serialized trace context\n * @returns OpenTelemetry context with the restored trace\n */\nexport async function deserializeTraceCarrier(\n  traceCarrier: Record<string, string>\n) {\n  const otel = await OtelApi.value;\n  if (!otel) return;\n  // Extract the context from the carrier\n  return otel.propagation.extract(otel.context.active(), traceCarrier);\n}\n\n/**\n * Runs a function within the context of a deserialized trace\n * @param traceCarrier The serialized trace carrier (optional)\n * @param fn The function to run within the trace context\n * @returns The result of the function\n */\nexport async function withTraceContext<T>(\n  traceCarrier: Record<string, string> | undefined,\n  fn: () => Promise<T>\n): Promise<T> {\n  if (!traceCarrier) {\n    return fn();\n  }\n\n  const otel = await OtelApi.value;\n  if (!otel) return fn();\n\n  const extractedContext = await deserializeTraceCarrier(traceCarrier);\n  if (!extractedContext) {\n    return fn();\n  }\n\n  return otel.context.with(extractedContext, async () => await fn());\n}\n\nconst OtelApi = once(async () => {\n  try {\n    return await import('@opentelemetry/api');\n  } catch {\n    runtimeLogger.info('OpenTelemetry not available, tracing will be disabled');\n    return null;\n  }\n});\n\nconst Tracer = once(async () => {\n  const api = await OtelApi.value;\n  if (!api) return null;\n  return api.trace.getTracer('workflow');\n});\n\nexport async function trace<T>(\n  spanName: string,\n  ...args:\n    | [fn: (span?: Span) => Promise<T>]\n    | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]\n): Promise<T> {\n  const [tracer, otel] = await Promise.all([Tracer.value, OtelApi.value]);\n  const { fn, opts } =\n    typeof args[0] === 'function'\n      ? { fn: args[0], opts: {} }\n      : { fn: args[1], opts: args[0] };\n  if (!fn) throw new Error('Function to trace must be provided');\n\n  if (!tracer || !otel) {\n    return await fn();\n  }\n\n  return tracer.startActiveSpan(spanName, opts, async (span) => {\n    try {\n      const result = await fn(span);\n      span.setStatus({ code: otel.SpanStatusCode.OK });\n      return result;\n    } catch (e) {\n      span.setStatus({\n        code: otel.SpanStatusCode.ERROR,\n        message: (e as Error).message,\n      });\n      applyWorkflowSuspensionToSpan(e, otel, span);\n      throw e;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n/**\n * Applies workflow suspension attributes to the given span if the error is a WorkflowSuspension\n * which is technically not an error, but an algebraic effect indicating suspension.\n */\nfunction applyWorkflowSuspensionToSpan(\n  error: unknown,\n  otel: typeof api,\n  span: api.Span\n) {\n  if (!error || !WorkflowSuspension.is(error)) {\n    return;\n  }\n\n  span.setStatus({ code: otel.SpanStatusCode.OK });\n  span.setAttributes({\n    ...Attr.WorkflowSuspensionState('suspended'),\n    ...Attr.WorkflowSuspensionStepCount(error.stepCount),\n    ...Attr.WorkflowSuspensionHookCount(error.hookCount),\n    ...Attr.WorkflowSuspensionWaitCount(error.waitCount),\n  });\n}\n\nexport async function getSpanContextForTraceCarrier(\n  carrier: Record<string, string>\n) {\n  const [deserialized, otel] = await Promise.all([\n    deserializeTraceCarrier(carrier),\n    OtelApi.value,\n  ]);\n  if (!deserialized || !otel) return;\n  return otel.trace.getSpanContext(deserialized);\n}\n\nexport async function getActiveSpan() {\n  return await withOtel((otel) => otel.trace.getActiveSpan());\n}\n\n/**\n * Wraps all methods of an object with tracing spans.\n * @param prefix - Prefix for span names (e.g., \"WORLD.runs\")\n * @param o - Object with methods to instrument\n * @returns Instrumented object with same interface\n */\nexport function instrumentObject<T extends object>(prefix: string, o: T): T {\n  const handlers = {} as T;\n  for (const key of Object.keys(o) as (keyof T)[]) {\n    if (typeof o[key] !== 'function') {\n      handlers[key] = o[key];\n    } else {\n      const f = o[key];\n      // @ts-expect-error\n      handlers[key] = async (...args: any[]) =>\n        trace(`${prefix}.${String(key)}`, {}, () => f(...args));\n    }\n  }\n  return handlers;\n}\n\nexport async function getSpanKind(field: keyof typeof SpanKind) {\n  return withOtel((x) => x.SpanKind[field]);\n}\n\nexport async function withOtel<T>(\n  fn: (otel: typeof api) => T\n): Promise<Awaited<T> | undefined> {\n  const otel = await OtelApi.value;\n  if (!otel) return undefined;\n  return await fn(otel);\n}\n\nexport function linkToCurrentContext(): Promise<[api.Link] | undefined> {\n  return withOtel((otel): [api.Link] | undefined => {\n    const context = otel.trace.getActiveSpan()?.spanContext();\n    if (!context) return;\n    return [{ context }];\n  });\n}\n\n// ============================================================\n// Baggage Propagation Utilities\n// ============================================================\n\n/**\n * Workflow context to propagate via baggage\n */\nexport interface WorkflowBaggageContext {\n  workflowRunId: string;\n  workflowName: string;\n}\n\n/**\n * Sets workflow context as OTEL baggage for automatic propagation.\n * Baggage is propagated across service boundaries via HTTP headers.\n * @param context - Workflow context to set as baggage\n * @returns A function to run within the baggage context\n */\nexport async function withWorkflowBaggage<T>(\n  context: WorkflowBaggageContext,\n  fn: () => Promise<T>\n): Promise<T> {\n  const otel = await OtelApi.value;\n  if (!otel) return fn();\n\n  // Create baggage with workflow context\n  const baggage = otel.propagation.createBaggage({\n    'workflow.run_id': { value: context.workflowRunId },\n    'workflow.name': { value: context.workflowName },\n  });\n\n  // Set baggage in context and run function\n  const contextWithBaggage = otel.propagation.setBaggage(\n    otel.context.active(),\n    baggage\n  );\n\n  return otel.context.with(contextWithBaggage, () => fn());\n}\n\n/**\n * Retrieves workflow context from OTEL baggage.\n * @returns Workflow context if present in baggage, undefined otherwise\n */\nexport async function getWorkflowBaggage(): Promise<\n  WorkflowBaggageContext | undefined\n> {\n  const otel = await OtelApi.value;\n  if (!otel) return undefined;\n\n  const baggage = otel.propagation.getBaggage(otel.context.active());\n  if (!baggage) return undefined;\n\n  const runId = baggage.getEntry('workflow.run_id')?.value;\n  const name = baggage.getEntry('workflow.name')?.value;\n\n  if (!runId || !name) return undefined;\n\n  return {\n    workflowRunId: runId,\n    workflowName: name,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"telemetry.js","sourceRoot":"","sources":["../src/telemetry.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as api from '@opentelemetry/api';\nimport type { Span, SpanKind, SpanOptions } from '@opentelemetry/api';\nimport { globalSingleton, once } from '@workflow/utils';\nimport { WorkflowSuspension } from './global.js';\nimport { runtimeLogger } from './logger.js';\nimport * as Attr from './telemetry/semantic-conventions.js';\n\n// ============================================================\n// Trace Context Propagation Utilities\n// ============================================================\n\n/**\n * Controls how workflow/step queue-handler spans relate to the run-origin\n * trace context carried in queue messages:\n *\n * - `'linked'` (default): each invocation starts a NEW root trace; the\n *   run-origin context (and the incoming delivery context) are attached as\n *   span links. This keeps traces bounded per invocation instead of\n *   stitching a long-lived run into one giant trace.\n * - `'continuous'`: the restored run-origin context becomes the parent of\n *   the invocation span (legacy behavior), producing a single trace that\n *   spans the entire run.\n */\nexport type WorkflowTraceMode = 'linked' | 'continuous';\n\n/**\n * Unrecognized `WORKFLOW_TRACE_MODE` values we already warned about. On\n * `globalThis` (see `globalSingleton`) so the warning stays once per process\n * rather than once per bundler layer.\n */\nconst traceModeWarnings = globalSingleton(\n  '@workflow/core//traceModeWarnings',\n  1,\n  () => ({ unrecognized: new Set<string>() })\n);\n\n/**\n * Resolves the active trace mode from the `WORKFLOW_TRACE_MODE` env var.\n * Defaults to `'linked'`; any value other than `'continuous'` selects it.\n * Unrecognized non-empty values (e.g. typos like `continous`) emit a\n * one-time warning so silent fallback to `linked` is at least visible.\n */\nexport function getWorkflowTraceMode(): WorkflowTraceMode {\n  const value = process.env.WORKFLOW_TRACE_MODE;\n  if (value === 'continuous') return 'continuous';\n  if (\n    value &&\n    value !== 'linked' &&\n    !traceModeWarnings.unrecognized.has(value)\n  ) {\n    traceModeWarnings.unrecognized.add(value);\n    runtimeLogger.warn(\n      `Unrecognized WORKFLOW_TRACE_MODE value \"${value}\"; expected \"linked\" or \"continuous\". Falling back to \"linked\".`\n    );\n  }\n  return 'linked';\n}\n\n/**\n * Returns whether a serialized trace carrier is usable, i.e. present and\n * non-empty. `serializeTraceCarrier()` returns `{}` when no OTEL SDK is\n * registered or no span is active, and `start()` always attaches the\n * carrier to the first queue message, so an empty carrier must be treated\n * the same as an absent one wherever the trace-mode logic branches.\n */\nexport function isUsableTraceCarrier(\n  carrier: Record<string, string> | undefined\n): carrier is Record<string, string> {\n  return carrier !== undefined && Object.keys(carrier).length > 0;\n}\n\n/**\n * Returns the trace carrier to attach to messages the current invocation\n * enqueues. In `linked` mode the ORIGINAL run-origin carrier is forwarded\n * unchanged (when usable) so every future invocation links back to the same\n * origin; otherwise (`continuous` mode, or no usable incoming carrier)\n * the current (active) context is serialized, so the trace keeps chaining\n * (continuous) or the first instrumented invocation becomes the de-facto\n * origin (linked).\n */\nexport function getNextTraceCarrier(\n  traceMode: WorkflowTraceMode,\n  incomingCarrier: Record<string, string> | undefined\n): Promise<Record<string, string>> {\n  return traceMode === 'linked' && isUsableTraceCarrier(incomingCarrier)\n    ? Promise.resolve(incomingCarrier)\n    : serializeTraceCarrier();\n}\n\n/**\n * Builds the span links for a queue-delivered invocation span\n * (`workflow.execute` / `step.execute`):\n *\n * - In `linked` mode the invocation span is a CHILD of the local delivery\n *   (flow-route) context, so the only link is to the run-origin context\n *   from the message's trace carrier, connecting this bounded per-invocation\n *   trace back to where the run was started. The run-origin context is a\n *   link, never a parent, and re-enqueues forward the original carrier\n *   unchanged, so the whole run is never stitched into one giant trace.\n *   The link is skipped when the carrier is absent, empty, or invalid.\n * - In `continuous` mode the run-origin context is restored as the parent\n *   instead, and the link points at the incoming delivery context.\n */\nexport async function buildInvocationSpanLinks(\n  traceMode: WorkflowTraceMode,\n  incomingCarrier: Record<string, string> | undefined\n): Promise<api.Link[] | undefined> {\n  if (traceMode !== 'linked') return linkToCurrentContext();\n  const originLink = await linkToTraceCarrier(\n    isUsableTraceCarrier(incomingCarrier) ? incomingCarrier : undefined\n  );\n  return originLink ? [originLink] : undefined;\n}\n\n/**\n * Serializes the current trace context into a format that can be passed through queues\n * @returns A record of strings representing the trace context\n */\nexport async function serializeTraceCarrier(): Promise<Record<string, string>> {\n  const otel = await OtelApi.value;\n  if (!otel) return {};\n  const carrier: Record<string, string> = {};\n  // Inject the current context into the carrier\n  otel.propagation.inject(otel.context.active(), carrier);\n  return carrier;\n}\n\n/**\n * Deserializes trace context and returns a context that can be used to continue the trace\n * @param traceCarrier The serialized trace context\n * @returns OpenTelemetry context with the restored trace\n */\nexport async function deserializeTraceCarrier(\n  traceCarrier: Record<string, string>\n) {\n  const otel = await OtelApi.value;\n  if (!otel) return;\n  // Extract the context from the carrier\n  return otel.propagation.extract(otel.context.active(), traceCarrier);\n}\n\n/**\n * Runs a function within the context of a deserialized trace\n * @param traceCarrier The serialized trace carrier (optional)\n * @param fn The function to run within the trace context\n * @returns The result of the function\n */\nexport async function withTraceContext<T>(\n  traceCarrier: Record<string, string> | undefined,\n  fn: () => Promise<T>\n): Promise<T> {\n  if (!traceCarrier) {\n    return fn();\n  }\n\n  const otel = await OtelApi.value;\n  if (!otel) return fn();\n\n  const extractedContext = await deserializeTraceCarrier(traceCarrier);\n  if (!extractedContext) {\n    return fn();\n  }\n\n  return otel.context.with(extractedContext, async () => await fn());\n}\n\nconst OtelApi = once(async () => {\n  // `@opentelemetry/api` is an optional peer dependency. The static specifier\n  // is intentional: esbuild-bundled targets (the CLI's\n  // `vercel-build-output-api` build, Nitro, Astro) ship a self-contained\n  // bundle with no node_modules, so the package must be *inlined* at build\n  // time for spans to work at runtime; a runtime-built specifier is opaque to\n  // esbuild and would silently disable tracing there. Bundlers that reject an\n  // unresolvable static `import()` when the peer isn't installed (Rollup/Vite,\n  // e.g. SvelteKit) instead externalize `@opentelemetry/api` in the workflow\n  // framework integration, which keeps the build green and still loads real\n  // OTel when the peer is present. Runtime semantics: present → loaded, absent\n  // → caught and tracing disabled.\n  try {\n    return await import('@opentelemetry/api');\n  } catch {\n    runtimeLogger.info('OpenTelemetry not available, tracing will be disabled');\n    return null;\n  }\n});\n\nconst Tracer = once(async () => {\n  const api = await OtelApi.value;\n  if (!api) return null;\n  const tracer = api.trace.getTracer('workflow');\n  logOtelDiagnosticOnce(api, tracer);\n  return tracer;\n});\n\nconst StepExecutionDurationHistogram = once(async () => {\n  const otel = await OtelApi.value;\n  if (!otel) return null;\n  // service.name is a resource attribute, applied by the configured provider.\n  return otel.metrics\n    .getMeter('workflow')\n    .createHistogram('workflow.step.execute.duration', {\n      description: 'Duration of user step execution',\n      unit: 'ms',\n    });\n});\n\n/**\n * One-shot runtime diagnostic (DEBUG=workflow:* only), same shape as the one\n * world-vercel emits tagged `world-vercel`: prints how this module instance\n * of `@opentelemetry/api` sees the global registration, so a deployment's\n * logs show the two packages' views side by side.\n */\n// per-copy-ok: this diagnostic reports how THIS module instance sees the global\n// OTel registration, which is the whole point of the log. With several copies\n// in a process, each one's view is what is worth seeing.\nlet otelDiagLogged = false;\n\nfunction describeThrownValue(value: unknown): string {\n  try {\n    if (\n      typeof value === 'object' &&\n      value !== null &&\n      'message' in value &&\n      typeof value.message === 'string'\n    ) {\n      return value.message;\n    }\n    return String(value);\n  } catch {\n    return 'Unknown error';\n  }\n}\n\nfunction logOtelDiagnosticOnce(otel: typeof api, tracer: api.Tracer): void {\n  const debugEnabled =\n    typeof process !== 'undefined' &&\n    typeof process.env.DEBUG === 'string' &&\n    (process.env.DEBUG.includes('workflow:') || process.env.DEBUG === '*');\n  if (otelDiagLogged || !debugEnabled) return;\n  otelDiagLogged = true;\n  try {\n    const g = (globalThis as Record<symbol, unknown>)[\n      Symbol.for('opentelemetry.js.api.1')\n    ] as { version?: string } | undefined;\n    const provider = otel.trace.getTracerProvider();\n    const delegate =\n      (provider as { getDelegate?: () => unknown }).getDelegate?.() ?? provider;\n    const probe = tracer.startSpan('workflow.otel.probe.core');\n    console.warn(\n      '[workflow:otel-diag] core',\n      JSON.stringify({\n        globalRegistrationVersion: g?.version ?? null,\n        providerCtor: provider?.constructor?.name ?? null,\n        delegateCtor: (delegate as object | null)?.constructor?.name ?? null,\n        tracerCtor: tracer?.constructor?.name ?? null,\n        probeCtor: probe?.constructor?.name ?? null,\n        probeRecording: probe.isRecording(),\n      })\n    );\n    probe.end();\n  } catch (error) {\n    console.warn(\n      '[workflow:otel-diag] core failed:',\n      error instanceof Error ? error.message : error\n    );\n  }\n}\n\nexport async function trace<T>(\n  spanName: string,\n  ...args:\n    | [fn: (span?: Span) => Promise<T>]\n    | [opts: SpanOptions, fn: (span?: Span) => Promise<T>]\n): Promise<T> {\n  const [tracer, otel] = await Promise.all([Tracer.value, OtelApi.value]);\n  const { fn, opts } =\n    typeof args[0] === 'function'\n      ? { fn: args[0], opts: {} }\n      : { fn: args[1], opts: args[0] };\n  if (!fn) throw new Error('Function to trace must be provided');\n\n  if (!tracer || !otel) {\n    return await fn();\n  }\n\n  return tracer.startActiveSpan(spanName, opts, async (span) => {\n    try {\n      const result = await fn(span);\n      span.setStatus({ code: otel.SpanStatusCode.OK });\n      return result;\n    } catch (e) {\n      if (WorkflowSuspension.is(e)) {\n        span.setStatus({ code: otel.SpanStatusCode.OK });\n        applyWorkflowSuspensionToSpan(e, span);\n      } else {\n        span.setStatus({\n          code: otel.SpanStatusCode.ERROR,\n          message: describeThrownValue(e),\n        });\n      }\n      throw e;\n    } finally {\n      span.end();\n    }\n  });\n}\n\n/** Starts a child span without installing it as the active context. */\nexport async function startTraceSpan(spanName: string) {\n  const [tracer, otel] = await Promise.all([Tracer.value, OtelApi.value]);\n  if (!tracer || !otel) return { end() {}, fail() {} };\n\n  const span = tracer.startSpan(spanName);\n  let ended = false;\n  const finish = (status: api.SpanStatus) => {\n    if (ended) return;\n    ended = true;\n    span.setStatus(status);\n    span.end();\n  };\n\n  return {\n    end: () => finish({ code: otel.SpanStatusCode.OK }),\n    fail: (error: unknown) =>\n      finish({\n        code: otel.SpanStatusCode.ERROR,\n        message: describeThrownValue(error),\n      }),\n  };\n}\n\n/** Bind work to the currently active span even when it starts from a child. */\nexport async function bindActiveTraceContext<Args extends unknown[], Result>(\n  fn: (...args: Args) => Result\n): Promise<(...args: Args) => Result> {\n  const otel = await OtelApi.value;\n  return otel ? otel.context.bind(otel.context.active(), fn) : fn;\n}\n\n/** Keeps a parked workflow's ambient trace context aligned with each resume. */\nexport async function createRefreshableTraceContext() {\n  const otel = await OtelApi.value;\n  if (!otel) {\n    return { refresh() {}, run: <T>(fn: () => T): T => fn() };\n  }\n\n  let current = otel.context.active();\n  const context: api.Context = {\n    getValue: (key) => current.getValue(key),\n    setValue: (key, value) => current.setValue(key, value),\n    deleteValue: (key) => current.deleteValue(key),\n  };\n\n  return {\n    refresh: () => {\n      current = otel.context.active();\n    },\n    run: <T>(fn: () => T): T => otel.context.with(context, fn),\n  };\n}\n\n/**\n * Emit a span whose start is back-dated to `startEpochMs` and whose end is now,\n * so its duration reflects an interval only measurable at its end (e.g.\n * time-to-first-chunk, known when the first chunk arrives). Unlike `trace()`,\n * this records an already-elapsed span in one shot rather than wrapping a\n * callback. No-op when OpenTelemetry is not available.\n */\nexport async function recordElapsedSpan(\n  spanName: string,\n  startEpochMs: number,\n  opts?: SpanOptions\n): Promise<void> {\n  const tracer = await Tracer.value;\n  if (!tracer) return;\n  tracer.startSpan(spanName, { ...opts, startTime: startEpochMs }).end();\n}\n\n/**\n * Records the same user-code interval as the inner `step.execute` span. The\n * configured OpenTelemetry meter provider attaches resource dimensions such as\n * service.name, so this avoids accepting a caller-controlled service tag.\n */\nexport async function recordStepExecutionDuration(\n  durationMs: number,\n  status: 'ok' | 'error'\n): Promise<void> {\n  const histogram = await StepExecutionDurationHistogram.value;\n  histogram?.record(durationMs, { 'workflow.step.status': status });\n}\n\n/**\n * Applies the workflow suspension algebraic effect to an active span.\n */\nexport function applyWorkflowSuspensionToSpan(\n  error: WorkflowSuspension,\n  span: api.Span\n): void {\n  span.setAttributes({\n    ...Attr.WorkflowSuspensionState('suspended'),\n    ...Attr.WorkflowSuspensionStepCount(error.stepCount),\n    ...Attr.WorkflowSuspensionHookCount(error.hookCount),\n    ...Attr.WorkflowSuspensionWaitCount(error.waitCount),\n  });\n}\n\nexport async function getSpanContextForTraceCarrier(\n  carrier: Record<string, string>\n) {\n  const [deserialized, otel] = await Promise.all([\n    deserializeTraceCarrier(carrier),\n    OtelApi.value,\n  ]);\n  if (!deserialized || !otel) return;\n  return otel.trace.getSpanContext(deserialized);\n}\n\nexport async function getActiveSpan() {\n  return await withOtel((otel) => otel.trace.getActiveSpan());\n}\n\n/**\n * Wraps all methods of an object with tracing spans.\n * @param prefix - Prefix for span names (e.g., \"WORLD.runs\")\n * @param o - Object with methods to instrument\n * @returns Instrumented object with same interface\n */\nexport function instrumentObject<T extends object>(prefix: string, o: T): T {\n  const handlers = {} as T;\n  for (const key of Object.keys(o) as (keyof T)[]) {\n    if (typeof o[key] !== 'function') {\n      handlers[key] = o[key];\n    } else {\n      const f = o[key];\n      // @ts-expect-error\n      handlers[key] = async (...args: any[]) =>\n        trace(`${prefix}.${String(key)}`, {}, () => f(...args));\n    }\n  }\n  return handlers;\n}\n\nexport async function getSpanKind(field: keyof typeof SpanKind) {\n  return withOtel((x) => x.SpanKind[field]);\n}\n\nexport async function withOtel<T>(\n  fn: (otel: typeof api) => T\n): Promise<Awaited<T> | undefined> {\n  const otel = await OtelApi.value;\n  if (!otel) return undefined;\n  return await fn(otel);\n}\n\nexport function linkToCurrentContext(): Promise<[api.Link] | undefined> {\n  return withOtel((otel): [api.Link] | undefined => {\n    const context = otel.trace.getActiveSpan()?.spanContext();\n    if (!context) return;\n    return [{ context }];\n  });\n}\n\n/**\n * Builds a span link pointing at the span context embedded in a serialized\n * trace carrier (e.g. the run-origin context flowing through queue\n * messages). Returns `undefined` when OTEL is unavailable, the carrier is\n * absent, or it does not contain a valid span context.\n */\nexport async function linkToTraceCarrier(\n  carrier: Record<string, string> | undefined\n): Promise<api.Link | undefined> {\n  if (!carrier) return;\n  const [context, otel] = await Promise.all([\n    getSpanContextForTraceCarrier(carrier),\n    OtelApi.value,\n  ]);\n  if (!context || !otel) return;\n  if (!otel.trace.isSpanContextValid(context)) return;\n  return { context };\n}\n\n// ============================================================\n// Baggage Propagation Utilities\n// ============================================================\n\n/**\n * Workflow context to propagate via baggage\n */\nexport interface WorkflowBaggageContext {\n  workflowRunId: string;\n  workflowName: string;\n}\n\n/**\n * Sets workflow context as OTEL baggage for automatic propagation.\n * Baggage is propagated across service boundaries via HTTP headers.\n * @param context - Workflow context to set as baggage\n * @returns A function to run within the baggage context\n */\nexport async function withWorkflowBaggage<T>(\n  context: WorkflowBaggageContext,\n  fn: () => Promise<T>\n): Promise<T> {\n  const otel = await OtelApi.value;\n  if (!otel) return fn();\n\n  // Create baggage with workflow context\n  const baggage = otel.propagation.createBaggage({\n    'workflow.run_id': { value: context.workflowRunId },\n    'workflow.name': { value: context.workflowName },\n  });\n\n  // Set baggage in context and run function\n  const contextWithBaggage = otel.propagation.setBaggage(\n    otel.context.active(),\n    baggage\n  );\n\n  return otel.context.with(contextWithBaggage, () => fn());\n}\n\n/**\n * Retrieves workflow context from OTEL baggage.\n * @returns Workflow context if present in baggage, undefined otherwise\n */\nexport async function getWorkflowBaggage(): Promise<\n  WorkflowBaggageContext | undefined\n> {\n  const otel = await OtelApi.value;\n  if (!otel) return undefined;\n\n  const baggage = otel.propagation.getBaggage(otel.context.active());\n  if (!baggage) return undefined;\n\n  const runId = baggage.getEntry('workflow.run_id')?.value;\n  const name = baggage.getEntry('workflow.name')?.value;\n\n  if (!runId || !name) return undefined;\n\n  return {\n    workflowRunId: runId,\n    workflowName: name,\n  };\n}\n"]}

package/dist/test-support/orchestrator-context.d.ts

@@ -0,0 +1,25 @@
+import type { Event } from '@workflow/world';
+import type { WorkflowOrchestratorContext } from '../private.js';
+/**
+ * Builds an orchestrator context that replays a hand-written event log through
+ * the real workflow primitives (`createUseStep`, `createSleep`,
+ * `createCreateHook`), without a World or a VM entrypoint.
+ */
+export declare function setupWorkflowContext(events: Event[], options?: {
+    onDuplicateEvent?: (event: Event) => void;
+}): WorkflowOrchestratorContext;
+/**
+ * Deterministic correlation IDs from the ULID generator with seed 'test', in
+ * the order {@link setupWorkflowContext}'s generator mints them.
+ */
+export declare const CORR_IDS: string[];
+/**
+ * Runs `workflowFn` against `ctx`, racing it against the context's error
+ * channel so a `WorkflowSuspension` or a detected divergence surfaces as
+ * `error` rather than hanging.
+ */
+export declare function runWithDiscontinuation(ctx: WorkflowOrchestratorContext, workflowFn: () => Promise<any>): Promise<{
+    result?: any;
+    error?: any;
+}>;
+//# sourceMappingURL=orchestrator-context.d.ts.map

package/dist/test-support/orchestrator-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-context.d.ts","sourceRoot":"","sources":["../../src/test-support/orchestrator-context.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AAK7C,OAAO,KAAK,EAAE,2BAA2B,EAAE,MAAM,eAAe,CAAC;AAKjE;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,KAAK,EAAE,EACf,OAAO,GAAE;IAAE,gBAAgB,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAA;CAAO,GAC1D,2BAA2B,CA+D7B;AAED;;;GAGG;AACH,eAAO,MAAM,QAAQ,UAOpB,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,GAAG,EAAE,2BAA2B,EAChC,UAAU,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAC7B,OAAO,CAAC;IAAE,MAAM,CAAC,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,GAAG,CAAA;CAAE,CAAC,CAexC"}