pg-workflows 0.14.0 → 0.16.0

package/dist/index.cjs

@@ -65,10 +65,11 @@ var __export = (target, all) => {
 var exports_src = {};
 __export(exports_src, {
   workflow: () => workflow,
-  otelPlugin: () => otelPlugin,
+  isStepCached: () => isStepCached,
   createWorkflowRef: () => createWorkflowRef,
   WorkflowStatus: () => WorkflowStatus,
   WorkflowRunNotFoundError: () => WorkflowRunNotFoundError,
+  WorkflowRunInProgressError: () => WorkflowRunInProgressError,
   WorkflowEngineError: () => WorkflowEngineError,
   WorkflowEngine: () => WorkflowEngine,
   WorkflowClient: () => WorkflowClient
@@ -94,10 +95,11 @@ var WAIT_FOR_TIMELINE_SUFFIX = "wait-for";
 var invokeChildWorkflowTimelineKey = (stepId) => `${stepId}-${INVOKE_CHILD_WORKFLOW_TIMELINE_SUFFIX}`;
 var waitForTimelineKey = (stepId) => `${stepId}-${WAIT_FOR_TIMELINE_SUFFIX}`;
 var isInvokeChildWorkflowTimelineEntry = (entry) => !!entry && typeof entry === "object" && ("invokeChildWorkflow" in entry);
+var isStepCached = (timeline, stepId) => timeline[stepId]?.output !== undefined || isInvokeChildWorkflowTimelineEntry(timeline[invokeChildWorkflowTimelineKey(stepId)]);
 
 // src/db/migration.ts
 var MIGRATION_LOCK_ID = 738291645;
-var CURRENT_SCHEMA_VERSION = 6;
+var CURRENT_SCHEMA_VERSION = 7;
 async function runMigrations(db) {
   if (await isSchemaUpToDate(db)) {
     return;
@@ -176,6 +178,14 @@ async function runMigrations(db) {
   if (currentVersion < 6) {
     commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS priority integer DEFAULT 0 NOT NULL");
   }
+  if (currentVersion < 7) {
+    commands.push("ALTER TABLE workflow_runs ADD COLUMN IF NOT EXISTS singleton boolean DEFAULT false NOT NULL");
+    commands.push(`
+      CREATE UNIQUE INDEX IF NOT EXISTS workflow_runs_singleton_active_idx
+        ON workflow_runs (workflow_id)
+        WHERE singleton AND status IN ('pending', 'running')
+    `);
+  }
   if (currentVersion === 0) {
     commands.push(`INSERT INTO workflow_schema_version (version) VALUES (${CURRENT_SCHEMA_VERSION})`);
   } else {
@@ -215,9 +225,95 @@ async function getCurrentVersion(db) {
 
 // src/db/queries.ts
 var import_ksuid = __toESM(require("ksuid"));
+
+// src/error.ts
+function validateWorkflowId(workflowId) {
+  if (workflowId.length > MAX_WORKFLOW_ID_LENGTH) {
+    throw new WorkflowEngineError(`workflowId exceeds maximum length of ${MAX_WORKFLOW_ID_LENGTH} characters (got ${workflowId.length})`, workflowId);
+  }
+}
+function validateResourceId(resourceId) {
+  if (resourceId != null && resourceId.length > MAX_RESOURCE_ID_LENGTH) {
+    throw new WorkflowEngineError(`resourceId exceeds maximum length of ${MAX_RESOURCE_ID_LENGTH} characters (got ${resourceId.length})`);
+  }
+}
+
+class WorkflowEngineError extends Error {
+  workflowId;
+  runId;
+  cause;
+  issues;
+  constructor(message, workflowId, runId, cause = undefined, issues) {
+    super(message);
+    this.workflowId = workflowId;
+    this.runId = runId;
+    this.cause = cause;
+    this.issues = issues;
+    this.name = "WorkflowEngineError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, WorkflowEngineError);
+    }
+  }
+}
+
+class WorkflowRunNotFoundError extends WorkflowEngineError {
+  constructor(runId, workflowId) {
+    super("Workflow run not found", workflowId, runId);
+    this.name = "WorkflowRunNotFoundError";
+  }
+}
+
+class WorkflowRunInProgressError extends WorkflowEngineError {
+  constructor(workflowId, runId) {
+    super(`Workflow "${workflowId}" already has a running run; wait for it to pause, complete, fail, or be cancelled`, workflowId, runId);
+    this.name = "WorkflowRunInProgressError";
+  }
+}
+
+// src/types.ts
+var WorkflowStatus;
+((WorkflowStatus2) => {
+  WorkflowStatus2["PENDING"] = "pending";
+  WorkflowStatus2["RUNNING"] = "running";
+  WorkflowStatus2["PAUSED"] = "paused";
+  WorkflowStatus2["COMPLETED"] = "completed";
+  WorkflowStatus2["FAILED"] = "failed";
+  WorkflowStatus2["CANCELLED"] = "cancelled";
+})(WorkflowStatus ||= {});
+var _STEP_BASE_METHOD_TO_TYPE = {
+  run: "run" /* RUN */,
+  waitFor: "waitFor" /* WAIT_FOR */,
+  waitUntil: "waitUntil" /* WAIT_UNTIL */,
+  delay: "delay" /* DELAY */,
+  sleep: "delay" /* DELAY */,
+  pause: "pause" /* PAUSE */,
+  poll: "poll" /* POLL */,
+  invokeChildWorkflow: "invokeChildWorkflow" /* INVOKE_CHILD_WORKFLOW */
+};
+var STEP_BASE_METHOD_TYPES = new Map(Object.entries(_STEP_BASE_METHOD_TO_TYPE));
+
+// src/db/queries.ts
+var EMPTY_RUN_STATS = {
+  ["pending" /* PENDING */]: 0,
+  ["running" /* RUNNING */]: 0,
+  ["paused" /* PAUSED */]: 0,
+  ["completed" /* COMPLETED */]: 0,
+  ["failed" /* FAILED */]: 0,
+  ["cancelled" /* CANCELLED */]: 0
+};
 function generateKSUID(prefix) {
   return `${prefix ? `${prefix}_` : ""}${import_ksuid.default.randomSync().string}`;
 }
+function isUniqueViolation(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  if ("code" in error && error.code === "23505") {
+    return true;
+  }
+  const cause = "cause" in error ? error.cause : undefined;
+  return Boolean(cause && typeof cause === "object" && "code" in cause && cause.code === "23505");
+}
 function mapRowToWorkflowRun(row) {
   return {
     id: row.id,
@@ -243,7 +339,8 @@ function mapRowToWorkflowRun(row) {
     parentRunId: row.parent_run_id,
     parentStepId: row.parent_step_id,
     parentResourceId: row.parent_resource_id,
-    scheduledAt: row.scheduled_at ? new Date(row.scheduled_at) : null
+    scheduledAt: row.scheduled_at ? new Date(row.scheduled_at) : null,
+    singleton: Boolean(row.singleton)
   };
 }
 async function insertWorkflowRun({
@@ -259,11 +356,20 @@ async function insertWorkflowRun({
   parentRunId,
   parentStepId,
   parentResourceId,
-  scheduledAt
+  scheduledAt,
+  singleton = false
 }, db) {
   const runId = generateKSUID("run");
   const now = new Date;
-  const result = await db.executeSql(`INSERT INTO workflow_runs (
+  if (singleton) {
+    const active = await getActiveSingletonRun(workflowId, db);
+    if (active) {
+      throw new WorkflowRunInProgressError(workflowId, active.id);
+    }
+  }
+  let result;
+  try {
+    result = await db.executeSql(`INSERT INTO workflow_runs (
       id,
       resource_id,
       workflow_id,
@@ -281,30 +387,39 @@ async function insertWorkflowRun({
       parent_run_id,
       parent_step_id,
       parent_resource_id,
-      scheduled_at
+      scheduled_at,
+      singleton
     )
-    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18)
+    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18, $19)
     ON CONFLICT (idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
     RETURNING *`, [
-    runId,
-    resourceId ?? null,
-    workflowId,
-    currentStepId,
-    status,
-    JSON.stringify(input),
-    maxRetries,
-    priority,
-    timeoutAt,
-    now,
-    now,
-    "{}",
-    0,
-    idempotencyKey ?? null,
-    parentRunId ?? null,
-    parentStepId ?? null,
-    parentResourceId ?? null,
-    scheduledAt ?? null
-  ]);
+      runId,
+      resourceId ?? null,
+      workflowId,
+      currentStepId,
+      status,
+      JSON.stringify(input),
+      maxRetries,
+      priority,
+      timeoutAt,
+      now,
+      now,
+      "{}",
+      0,
+      idempotencyKey ?? null,
+      parentRunId ?? null,
+      parentStepId ?? null,
+      parentResourceId ?? null,
+      scheduledAt ?? null,
+      singleton
+    ]);
+  } catch (error) {
+    if (singleton && isUniqueViolation(error)) {
+      const active = await getActiveSingletonRun(workflowId, db);
+      throw new WorkflowRunInProgressError(workflowId, active?.id);
+    }
+    throw error;
+  }
   if (result.rows[0]) {
     return { run: mapRowToWorkflowRun(result.rows[0]), created: true };
   }
@@ -316,6 +431,20 @@ async function insertWorkflowRun({
   }
   return { run: mapRowToWorkflowRun(existing.rows[0]), created: false };
 }
+async function getActiveSingletonRun(workflowId, db) {
+  const result = await db.executeSql(`SELECT * FROM workflow_runs
+     WHERE workflow_id = $1
+       AND singleton
+       AND status IN ('pending', 'running')
+     LIMIT 1`, [workflowId]);
+  return result.rows[0] ? mapRowToWorkflowRun(result.rows[0]) : null;
+}
+async function assertSingletonSlotAvailable({ workflowId, exceptRunId }, db) {
+  const active = await getActiveSingletonRun(workflowId, db);
+  if (active && active.id !== exceptRunId) {
+    throw new WorkflowRunInProgressError(workflowId, active.id);
+  }
+}
 async function getWorkflowRun({
   runId,
   resourceId
@@ -430,7 +559,15 @@ async function updateWorkflowRun({
     ${whereClause}
     RETURNING *
   `;
-  const result = await db.executeSql(query, values);
+  let result;
+  try {
+    result = await db.executeSql(query, values);
+  } catch (error) {
+    if (data.status === "running" && isUniqueViolation(error)) {
+      throw new WorkflowRunInProgressError("unknown", runId);
+    }
+    throw error;
+  }
   const run = result.rows[0];
   if (!run) {
     return null;
@@ -511,6 +648,32 @@ async function getWorkflowRuns({
   const prevCursor = hasPrev && items.length > 0 ? items[0]?.id ?? null : null;
   return { items, nextCursor, prevCursor, hasMore, hasPrev };
 }
+async function getWorkflowRunStats({
+  resourceId,
+  workflowId
+}, db) {
+  const conditions = [];
+  const values = [];
+  let paramIndex = 1;
+  if (resourceId) {
+    conditions.push(`resource_id = $${paramIndex}`);
+    values.push(resourceId);
+    paramIndex++;
+  }
+  if (workflowId) {
+    conditions.push(`workflow_id = $${paramIndex}`);
+    values.push(workflowId);
+  }
+  const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const result = await db.executeSql(`SELECT status, COUNT(*)::int AS count FROM workflow_runs ${whereClause} GROUP BY status`, values);
+  const stats = { ...EMPTY_RUN_STATS };
+  for (const row of result.rows) {
+    if (row.status in stats) {
+      stats[row.status] = Number(row.count);
+    }
+  }
+  return stats;
+}
 async function withPostgresTransaction(db, callback, pool) {
   let txDb;
   let release;
@@ -536,43 +699,6 @@ async function withPostgresTransaction(db, callback, pool) {
   }
 }
 
-// src/error.ts
-function validateWorkflowId(workflowId) {
-  if (workflowId.length > MAX_WORKFLOW_ID_LENGTH) {
-    throw new WorkflowEngineError(`workflowId exceeds maximum length of ${MAX_WORKFLOW_ID_LENGTH} characters (got ${workflowId.length})`, workflowId);
-  }
-}
-function validateResourceId(resourceId) {
-  if (resourceId != null && resourceId.length > MAX_RESOURCE_ID_LENGTH) {
-    throw new WorkflowEngineError(`resourceId exceeds maximum length of ${MAX_RESOURCE_ID_LENGTH} characters (got ${resourceId.length})`);
-  }
-}
-
-class WorkflowEngineError extends Error {
-  workflowId;
-  runId;
-  cause;
-  issues;
-  constructor(message, workflowId, runId, cause = undefined, issues) {
-    super(message);
-    this.workflowId = workflowId;
-    this.runId = runId;
-    this.cause = cause;
-    this.issues = issues;
-    this.name = "WorkflowEngineError";
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, WorkflowEngineError);
-    }
-  }
-}
-
-class WorkflowRunNotFoundError extends WorkflowEngineError {
-  constructor(runId, workflowId) {
-    super("Workflow run not found", workflowId, runId);
-    this.name = "WorkflowRunNotFoundError";
-  }
-}
-
 // src/priority.ts
 var PRIORITY_LEVELS = { high: 100, normal: 0, low: -100 };
 function priorityToInt(value) {
@@ -597,28 +723,6 @@ function resolvePriority(...candidates) {
   return PRIORITY_LEVELS.normal;
 }
 
-// src/types.ts
-var WorkflowStatus;
-((WorkflowStatus2) => {
-  WorkflowStatus2["PENDING"] = "pending";
-  WorkflowStatus2["RUNNING"] = "running";
-  WorkflowStatus2["PAUSED"] = "paused";
-  WorkflowStatus2["COMPLETED"] = "completed";
-  WorkflowStatus2["FAILED"] = "failed";
-  WorkflowStatus2["CANCELLED"] = "cancelled";
-})(WorkflowStatus ||= {});
-var _STEP_BASE_METHOD_TO_TYPE = {
-  run: "run" /* RUN */,
-  waitFor: "waitFor" /* WAIT_FOR */,
-  waitUntil: "waitUntil" /* WAIT_UNTIL */,
-  delay: "delay" /* DELAY */,
-  sleep: "delay" /* DELAY */,
-  pause: "pause" /* PAUSE */,
-  poll: "poll" /* POLL */,
-  invokeChildWorkflow: "invokeChildWorkflow" /* INVOKE_CHILD_WORKFLOW */
-};
-var STEP_BASE_METHOD_TYPES = new Map(Object.entries(_STEP_BASE_METHOD_TO_TYPE));
-
 // src/client.ts
 var LOG_PREFIX = "[WorkflowClient]";
 var defaultLogger = {
@@ -647,11 +751,10 @@ class WorkflowClient {
     const db = {
       executeSql: (text, values) => this.pool.query(text, values)
     };
-    if (boss) {
-      this.boss = boss;
-    } else {
-      this.boss = new import_pg_boss.PgBoss({ db, schema: DEFAULT_PGBOSS_SCHEMA });
-    }
+    this.boss = boss ?? new import_pg_boss.PgBoss({ db, schema: DEFAULT_PGBOSS_SCHEMA });
+    this.boss.on("error", (error) => {
+      this.logger.error("pg-boss error", error);
+    });
     this.db = db;
   }
   async start() {
@@ -680,6 +783,7 @@ class WorkflowClient {
     let resourceId;
     let idempotencyKey;
     let options;
+    let singleton = false;
     if (typeof refOrParams === "function" && "id" in refOrParams) {
       const ref = refOrParams;
       workflowId = ref.id;
@@ -687,6 +791,7 @@ class WorkflowClient {
       options = optionsArg;
       resourceId = optionsArg?.resourceId;
       idempotencyKey = optionsArg?.idempotencyKey;
+      singleton = optionsArg?.singleton ?? ref.singleton === true;
       if (ref.inputSchema) {
         const result = await ref.inputSchema["~standard"].validate(input);
         if (result.issues) {
@@ -700,6 +805,7 @@ class WorkflowClient {
       resourceId = params.resourceId;
       idempotencyKey = params.idempotencyKey;
       options = params.options;
+      singleton = params.options?.singleton === true;
     }
     validateWorkflowId(workflowId);
     validateResourceId(resourceId);
@@ -714,7 +820,8 @@ class WorkflowClient {
         maxRetries: options?.retries ?? 0,
         priority: resolvePriority(options?.priority),
         timeoutAt,
-        idempotencyKey
+        idempotencyKey,
+        singleton
       }, _db);
       if (created) {
         const job = {
@@ -744,6 +851,9 @@ class WorkflowClient {
   }) {
     await this.ensureStarted();
     const run = await this.getRun({ runId, resourceId });
+    if (run.singleton) {
+      await assertSingletonSlotAvailable({ workflowId: run.workflowId, exceptRunId: run.id }, this.db);
+    }
     const job = {
       runId: run.id,
       resourceId: resourceId ?? run.resourceId ?? undefined,
@@ -921,6 +1031,16 @@ class WorkflowClient {
       workflowId
     }, this.db);
   }
+  async getStats({
+    resourceId,
+    workflowId
+  } = {}) {
+    await this.ensureStarted();
+    if (workflowId)
+      validateWorkflowId(workflowId);
+    validateResourceId(resourceId);
+    return getWorkflowRunStats({ resourceId, workflowId }, this.db);
+  }
   async ensureStarted() {
     if (!this._started) {
       await this.start();
@@ -936,6 +1056,7 @@ function createWorkflowRef(id, options) {
     timeout: defineOptions?.timeout,
     retries: defineOptions?.retries,
     priority: defineOptions?.priority,
+    singleton: defineOptions?.singleton ?? options?.singleton,
     schedule: defineOptions?.schedule,
     timezone: defineOptions?.timezone
   });
@@ -944,16 +1065,29 @@ function createWorkflowRef(id, options) {
     value: options?.inputSchema,
     enumerable: true
   });
+  Object.defineProperty(ref, "singleton", {
+    value: options?.singleton,
+    enumerable: true
+  });
   return ref;
 }
 function createWorkflowFactory(plugins = []) {
-  const factory = (id, handler, { inputSchema, timeout, retries, priority, schedule, timezone } = {}) => ({
+  const factory = (id, handler, {
+    inputSchema,
+    timeout,
+    retries,
+    priority,
+    singleton,
+    schedule,
+    timezone
+  } = {}) => ({
     id,
     handler,
     inputSchema,
     timeout,
     retries,
     priority,
+    singleton,
     schedule,
     timezone,
     plugins: plugins.length > 0 ? plugins : undefined
@@ -1166,11 +1300,10 @@ class WorkflowEngine {
     const db = {
       executeSql: (text, values) => this.pool.query(text, values)
     };
-    if (boss) {
-      this.boss = boss;
-    } else {
-      this.boss = new import_pg_boss2.PgBoss({ db, schema: DEFAULT_PGBOSS_SCHEMA });
-    }
+    this.boss = boss ?? new import_pg_boss2.PgBoss({ db, schema: DEFAULT_PGBOSS_SCHEMA });
+    this.boss.on("error", (error) => {
+      this.logger.error("pg-boss error", error);
+    });
     this.db = this.boss.getDb();
   }
   async start(asEngine = true, {
@@ -1224,6 +1357,10 @@ class WorkflowEngine {
       try {
         await this.createWorkflowRun({ workflowId, input: {}, scheduledAt });
       } catch (error) {
+        if (error instanceof WorkflowRunInProgressError) {
+          this.logger.log(`Skipping schedule fire for "${workflowId}": a run is already in progress`, { workflowId, runId: error.runId });
+          return;
+        }
         this.logger.error(`Schedule fire failed to start a run for workflow "${workflowId}"`, error instanceof Error ? error : new Error(String(error)), { workflowId });
         throw error;
       }
@@ -1373,7 +1510,8 @@ class WorkflowEngine {
       parentRunId,
       parentStepId,
       parentResourceId,
-      scheduledAt
+      scheduledAt,
+      singleton: workflow2.singleton === true || options?.singleton === true
     }, targetDb);
     const insertAndEnqueue = async (targetDb) => {
       const result = await insertRun(targetDb);
@@ -1532,6 +1670,9 @@ class WorkflowEngine {
   }) {
     await this.checkIfHasStarted();
     const run = await this.getRun({ runId, resourceId });
+    if (run.singleton) {
+      await assertSingletonSlotAvailable({ workflowId: run.workflowId, exceptRunId: run.id }, this.db);
+    }
     const jobResourceId = resourceId ?? run.resourceId ?? undefined;
     const job = {
       runId: run.id,
@@ -2329,177 +2470,16 @@ ${error.stack}` : String(error)
       workflowId
     }, this.db);
   }
-}
-// src/plugins/otel.ts
-var import_api = require("@opentelemetry/api");
-var DEFAULT_PREFIX = "pg_workflows";
-function isCachedHit(timeline, stepId, kind) {
-  const entry = timeline[stepId];
-  if (entry && typeof entry === "object" && "output" in entry && entry.output !== undefined) {
-    return true;
-  }
-  if (kind === "invokeChildWorkflow" && timeline[invokeChildWorkflowTimelineKey(stepId)]) {
-    return true;
+  async getStats({
+    resourceId,
+    workflowId
+  } = {}) {
+    if (workflowId)
+      validateWorkflowId(workflowId);
+    validateResourceId(resourceId);
+    return getWorkflowRunStats({ resourceId, workflowId }, this.db);
   }
-  return false;
-}
-function otelPlugin(options = {}) {
-  const tracer = options.tracer ?? import_api.trace.getTracer("pg-workflows");
-  const prefix = options.spanNamePrefix ?? DEFAULT_PREFIX;
-  const extraAttrs = options.attributes;
-  return {
-    name: "opentelemetry",
-    methods: (step, context) => {
-      const wrapVoidish = (kind, base) => {
-        return async (stepId, ...args) => {
-          if (isCachedHit(context.timeline, stepId, kind)) {
-            return base(stepId, ...args);
-          }
-          const capturedCtx = import_api.context.active();
-          const startTime = new Date;
-          let result;
-          let originalErr;
-          let thrownError;
-          try {
-            result = await base(stepId, ...args);
-          } catch (err) {
-            originalErr = err;
-            thrownError = err instanceof Error ? err : new Error(String(err));
-          }
-          const span = tracer.startSpan(`${prefix}.step.${kind}`, {
-            startTime,
-            attributes: { "step.id": stepId, "step.type": kind }
-          }, capturedCtx);
-          if (thrownError) {
-            span.recordException(thrownError);
-            span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: thrownError.message });
-            span.end();
-            throw originalErr;
-          }
-          span.setStatus({ code: import_api.SpanStatusCode.OK });
-          span.end();
-          return result;
-        };
-      };
-      return {
-        run: async (stepId, handler) => {
-          if (isCachedHit(context.timeline, stepId, "run")) {
-            return step.run(stepId, handler);
-          }
-          const capturedCtx = import_api.context.active();
-          const startTime = new Date;
-          let result;
-          let originalErr;
-          let thrownError;
-          try {
-            result = await step.run(stepId, handler);
-          } catch (err) {
-            originalErr = err;
-            thrownError = err instanceof Error ? err : new Error(String(err));
-          }
-          if (result === undefined && !thrownError) {
-            return;
-          }
-          const span = tracer.startSpan(`${prefix}.step.run`, {
-            startTime,
-            attributes: { "step.id": stepId, "step.type": "run" }
-          }, capturedCtx);
-          if (thrownError) {
-            span.recordException(thrownError);
-            span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: thrownError.message });
-            span.end();
-            throw originalErr;
-          }
-          span.setStatus({ code: import_api.SpanStatusCode.OK });
-          span.end();
-          return result;
-        },
-        waitFor: wrapVoidish("waitFor", step.waitFor),
-        delay: wrapVoidish("delay", step.delay),
-        sleep: wrapVoidish("delay", step.delay),
-        waitUntil: wrapVoidish("waitUntil", step.waitUntil),
-        pause: wrapVoidish("pause", step.pause),
-        poll: async (stepId, conditionFn, pollOptions) => {
-          const capturedCtx = import_api.context.active();
-          const startTime = new Date;
-          let result;
-          let originalErr;
-          let thrownError;
-          try {
-            result = await step.poll(stepId, conditionFn, pollOptions);
-          } catch (err) {
-            originalErr = err;
-            thrownError = err instanceof Error ? err : new Error(String(err));
-          }
-          const span = tracer.startSpan(`${prefix}.step.poll`, {
-            startTime,
-            attributes: { "step.id": stepId, "step.type": "poll" }
-          }, capturedCtx);
-          if (thrownError) {
-            span.recordException(thrownError);
-            span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: thrownError.message });
-            span.end();
-            throw originalErr;
-          }
-          span.setStatus({ code: import_api.SpanStatusCode.OK });
-          span.end();
-          return result;
-        },
-        invokeChildWorkflow: async (stepId, refOrParams, inputArg, optionsArg) => {
-          if (isCachedHit(context.timeline, stepId, "invokeChildWorkflow")) {
-            return step.invokeChildWorkflow(stepId, refOrParams, inputArg, optionsArg);
-          }
-          const capturedCtx = import_api.context.active();
-          const startTime = new Date;
-          let result;
-          let originalErr;
-          let thrownError;
-          try {
-            result = await step.invokeChildWorkflow(stepId, refOrParams, inputArg, optionsArg);
-          } catch (err) {
-            originalErr = err;
-            thrownError = err instanceof Error ? err : new Error(String(err));
-          }
-          const span = tracer.startSpan(`${prefix}.step.invokeChildWorkflow`, {
-            startTime,
-            attributes: { "step.id": stepId, "step.type": "invokeChildWorkflow" }
-          }, capturedCtx);
-          if (thrownError) {
-            span.recordException(thrownError);
-            span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: thrownError.message });
-            span.end();
-            throw originalErr;
-          }
-          span.setStatus({ code: import_api.SpanStatusCode.OK });
-          span.end();
-          return result;
-        }
-      };
-    },
-    wrap: (context, next) => tracer.startActiveSpan(`${prefix}.workflow.run`, {
-      attributes: {
-        "workflow.id": context.workflowId,
-        "workflow.run_id": context.runId,
-        "workflow.attempt": context.attempt,
-        ...context.resourceId ? { "workflow.resource_id": context.resourceId } : {},
-        ...extraAttrs ? extraAttrs(context) : {}
-      }
-    }, async (span) => {
-      try {
-        const result = await next();
-        span.setStatus({ code: import_api.SpanStatusCode.OK });
-        return result;
-      } catch (err) {
-        const error = err instanceof Error ? err : new Error(String(err));
-        span.recordException(error);
-        span.setStatus({ code: import_api.SpanStatusCode.ERROR, message: error.message });
-        throw err;
-      } finally {
-        span.end();
-      }
-    })
-  };
 }
 
-//# debugId=5FA47CDFF028114064756E2164756E21
+//# debugId=B101AE54CEFCC2C064756E2164756E21
 //# sourceMappingURL=index.js.map