@usehelical/workflows 0.0.1-alpha.12 → 0.0.1-alpha.2

package/dist/index.js

@@ -1,1028 +0,0 @@
-import { createRunHandle, getRun, withDbRetry, executeWorkflow, deserialize, serialize, WorkflowNotFoundError, QueueNotFoundError, cancelRun, RunNotFoundError, insertPendingRun, MaxRecoveryAttemptsExceededError } from './chunk-WKVKC6AI.js';
-import crypto from 'crypto';
-import { Kysely, PostgresDialect, sql } from 'kysely';
-import { Pool } from 'pg';
-
-// core/internal/events/polling-loop.ts
-var PollingLoop = class {
-  intervalMs;
-  jitterFactor;
-  intervalHandle = null;
-  callback;
-  running = false;
-  constructor(intervalMs, callback, jitterFactor = 0.1) {
-    this.intervalMs = intervalMs;
-    this.callback = callback;
-    this.jitterFactor = Math.max(0, Math.min(1, jitterFactor));
-  }
-  calculateNextInterval() {
-    const jitterRange = this.intervalMs * this.jitterFactor;
-    const jitter = (Math.random() * 2 - 1) * jitterRange;
-    return Math.max(0, this.intervalMs + jitter);
-  }
-  scheduleNext() {
-    if (!this.running) {
-      return;
-    }
-    const nextInterval = this.calculateNextInterval();
-    this.intervalHandle = setTimeout(() => {
-      try {
-        this.callback();
-      } catch (error) {
-        console.error("PollingLoop callback error:", error);
-      }
-      this.scheduleNext();
-    }, nextInterval);
-  }
-  start() {
-    if (this.running) {
-      return;
-    }
-    this.running = true;
-    this.scheduleNext();
-  }
-  stop() {
-    this.running = false;
-    if (this.intervalHandle) {
-      clearTimeout(this.intervalHandle);
-      this.intervalHandle = null;
-    }
-  }
-  isRunning() {
-    return this.running;
-  }
-};
-
-// core/internal/events/event-bus-core.ts
-var EventBusCore = class {
-  constructor(config, pollingLoop) {
-    this.config = config;
-    this.allowWildcardSubscriptions = config.allowWildcardSubscriptions;
-    this.pollingLoop = pollingLoop;
-  }
-  subscribers = /* @__PURE__ */ new Map();
-  eventSequence = /* @__PURE__ */ new Map();
-  pollingLoop;
-  allowWildcardSubscriptions;
-  subscribe(subject, key, callback) {
-    const subscriptionKey = createSubscriptionKey(subject, key);
-    if (!this.subscribers.has(subscriptionKey)) {
-      this.subscribers.set(subscriptionKey, /* @__PURE__ */ new Set());
-    }
-    this.subscribers.get(subscriptionKey).add(callback);
-    this.pollingLoop.start();
-    return () => this.unsubscribe(subscriptionKey, callback);
-  }
-  unsubscribe(subscriptionKey, callback) {
-    const subscriptionCallbacks = this.subscribers.get(subscriptionKey);
-    if (subscriptionCallbacks) {
-      subscriptionCallbacks.delete(callback);
-      if (subscriptionCallbacks.size === 0) {
-        this.subscribers.delete(subscriptionKey);
-        this.eventSequence.delete(subscriptionKey);
-      }
-    }
-    if (this.subscribers.size === 0) {
-      this.pollingLoop.stop();
-    }
-  }
-  emitEvent(subject, key, event, eventChangeId) {
-    const subscriptionKeys = [createSubscriptionKey(subject, key)].concat(
-      this.allowWildcardSubscriptions ? [createSubscriptionKey(subject, "*")] : []
-    );
-    for (const subscriptionKey of subscriptionKeys) {
-      const subscribers = this.subscribers.get(subscriptionKey);
-      if (subscribers) {
-        for (const subscriptionCallback of subscribers) {
-          subscriptionCallback(event);
-        }
-      }
-    }
-    this.eventSequence.set(subscriptionKeys[0], eventChangeId);
-  }
-  checkHasSubscribers(subject, key) {
-    const subscriptionKeys = [createSubscriptionKey(subject, key)].concat(
-      this.allowWildcardSubscriptions ? [createSubscriptionKey(subject, "*")] : []
-    );
-    return subscriptionKeys.some((subscriptionKey) => this.subscribers.has(subscriptionKey));
-  }
-  getEventSequence(subject, key) {
-    return this.eventSequence.get(createSubscriptionKey(subject, key)) ?? 0;
-  }
-  getSubscriptionKeys() {
-    return Array.from(this.subscribers.keys()).map(splitSubscriptionKey);
-  }
-};
-function createSubscriptionKey(subject, key) {
-  return `${subject}::${key}`;
-}
-function splitSubscriptionKey(subscriptionKey) {
-  return subscriptionKey.split("::");
-}
-
-// core/internal/repository/get-state.ts
-async function getState(db, runId, key) {
-  const result = await db.selectFrom("state").select(["key", "value", "change_id"]).where("run_id", "=", runId).where("key", "=", key).executeTakeFirst();
-  if (!result) {
-    return void 0;
-  }
-  return result.value;
-}
-
-// core/internal/repository/get-state-batch.ts
-async function getStateBatch(db, stateRetrievalRequests) {
-  const results = await db.selectFrom("state").select(["key", "value", "change_id", "run_id", "change_id"]).where(
-    "run_id",
-    "in",
-    stateRetrievalRequests.map((r) => r.runId)
-  ).where(
-    "key",
-    "in",
-    stateRetrievalRequests.map((r) => r.key)
-  ).execute();
-  return results.map((r) => ({
-    runId: r.run_id,
-    key: r.key,
-    value: r.value,
-    changeId: r.change_id
-  }));
-}
-
-// core/internal/events/state-event-bus.ts
-var POLLING_FALLBACK_INTERVAL_MS = 1e4;
-var StateEventBus = class {
-  constructor(db) {
-    this.db = db;
-    this.pollingLoop = new PollingLoop(POLLING_FALLBACK_INTERVAL_MS, this.handlePoll.bind(this));
-    this.bus = new EventBusCore({ allowWildcardSubscriptions: false }, this.pollingLoop);
-    this.pollingLoop.start();
-  }
-  bus;
-  pollingLoop;
-  handleNotify(payload) {
-    const [workflowId, key, changeIdString] = payload.split("::");
-    const changeId = Number(changeIdString);
-    if (!this.bus.checkHasSubscribers(workflowId, key) || this.bus.getEventSequence(workflowId, key) >= changeId) {
-      return;
-    }
-    getState(this.db, workflowId, key).then((state) => {
-      if (!state) {
-        return;
-      }
-      this.bus.emitEvent(workflowId, key, state, changeId);
-    });
-  }
-  async handlePoll() {
-    const stateRetrievalRequests = getStateRetrievalRequests(this.bus.getSubscriptionKeys());
-    if (stateRetrievalRequests.length === 0) {
-      return;
-    }
-    const states = await getStateBatch(this.db, stateRetrievalRequests);
-    for (const state of states) {
-      if (this.bus.getEventSequence(state.runId, state.key) >= state.changeId) {
-        continue;
-      }
-      this.bus.emitEvent(state.runId, state.key, state.value, state.changeId);
-    }
-  }
-  subscribe(workflowId, key, callback) {
-    return this.bus.subscribe(workflowId, key, callback);
-  }
-  emitEvent(workflowId, key, data, changeId) {
-    this.bus.emitEvent(workflowId, key, data, changeId);
-  }
-  destroy() {
-    this.pollingLoop.stop();
-  }
-};
-function getStateRetrievalRequests(keys) {
-  return keys.map((k) => {
-    const [runId, key] = k;
-    return {
-      runId,
-      key
-    };
-  });
-}
-async function getMessageBatch(db, messageRetrievalRequests) {
-  const uniquePairs = Array.from(
-    new Map(
-      messageRetrievalRequests.map((r) => [`${r.destinationWorkflowId}:${r.messageType}`, r])
-    ).values()
-  );
-  const results = await db.selectFrom("messages").select(["id", "payload", "type", "destination_run_id"]).where(
-    sql`(destination_run_id, type) IN (${sql.join(
-      uniquePairs.map((r) => sql`(${r.destinationWorkflowId}, ${r.messageType})`)
-    )})`
-  ).execute();
-  return results.map((r) => ({
-    id: r.id,
-    payload: r.payload,
-    type: r.type,
-    destinationRunId: r.destination_run_id
-  }));
-}
-
-// core/internal/events/message-event-bus.ts
-var POLLING_FALLBACK_INTERVAL_MS2 = 1e4;
-var MessageEventBus = class {
-  constructor(db) {
-    this.db = db;
-    this.pollingLoop = new PollingLoop(POLLING_FALLBACK_INTERVAL_MS2, this.handlePoll.bind(this));
-    this.bus = new EventBusCore({ allowWildcardSubscriptions: true }, this.pollingLoop);
-    this.pollingLoop.start();
-  }
-  bus;
-  pollingLoop;
-  handleNotify(payload) {
-    const [destinationWorkflowId, messageType, messageCount] = payload.split("::");
-    if (!this.bus.checkHasSubscribers(destinationWorkflowId, messageType)) {
-      return;
-    }
-    this.bus.emitEvent(destinationWorkflowId, messageType, void 0, Number(messageCount));
-  }
-  async handlePoll() {
-    const messageRetrievalRequests = getMessageRetrievalRequests(this.bus.getSubscriptionKeys());
-    if (messageRetrievalRequests.length === 0) {
-      return;
-    }
-    const messages = await getMessageBatch(this.db, messageRetrievalRequests);
-    for (const message of messages) {
-      this.bus.emitEvent(message.destinationRunId, message.type, void 0, 1);
-    }
-  }
-  subscribe(destinationWorkflowId, type, cb) {
-    return this.bus.subscribe(destinationWorkflowId, type, cb);
-  }
-  destroy() {
-    this.pollingLoop.stop();
-  }
-};
-function getMessageRetrievalRequests(subscriptionKeys) {
-  return subscriptionKeys.map(([destinationWorkflowId, messageType]) => ({
-    destinationWorkflowId,
-    messageType
-  }));
-}
-async function runWorkflow(ctx, wf, args = [], options = {}) {
-  const { db, executorId, workflowRegistry } = ctx;
-  const workflow = typeof wf === "string" ? workflowRegistry.getByName(wf) : workflowRegistry.getByWorkflowDefinition(wf);
-  if (!workflow) {
-    throw new WorkflowNotFoundError("Workflow not found");
-  }
-  const runId = options.id ?? crypto.randomUUID();
-  const { path } = await insertPendingRun(db, {
-    runId,
-    path: [runId],
-    inputs: serialize(args),
-    executorId,
-    workflowName: workflow.name
-  });
-  await executeWorkflow(ctx, {
-    runId,
-    runPath: path,
-    workflowName: workflow.name,
-    fn: workflow.fn,
-    args,
-    options
-  });
-  return createRunHandle(ctx, runId);
-}
-
-// core/internal/run-registry.ts
-var RunRegistry = class {
-  runs = /* @__PURE__ */ new Map();
-  registerRun(runId, entry) {
-    let state = "pending";
-    entry.promise.then(
-      () => {
-        state = "fulfilled";
-      },
-      () => {
-        state = "rejected";
-      }
-    );
-    this.runs.set(runId, {
-      ...entry,
-      getPromiseState: () => state
-    });
-  }
-  unregisterRun(runId) {
-    this.runs.delete(runId);
-  }
-  getRun(runId) {
-    return this.runs.get(runId);
-  }
-};
-
-// core/internal/repository/get-operations.ts
-async function getOperations(db, runId) {
-  const results = await db.selectFrom("operations").select(["output", "error"]).where("run_id", "=", runId).orderBy("sequence_id", "desc").execute();
-  return results.map((r) => ({
-    result: r.output ?? void 0,
-    error: r.error ?? void 0
-  }));
-}
-
-// core/internal/repository/get-pending-runs.ts
-async function getPendingRuns(db, executorId) {
-  const pendingRuns = await db.selectFrom("runs").select(["id", "path", "inputs", "workflow_name"]).where("status", "=", "PENDING" /* PENDING */).where("executor_id", "=", executorId).execute();
-  return pendingRuns.map((run) => ({
-    id: run.id,
-    path: run.path,
-    inputs: run.inputs,
-    workflowName: run.workflow_name
-  }));
-}
-var DEFAULT_MAX_RETRIES = 10;
-async function upsertRun(db, options) {
-  const incrementAttempts = options.isRecovery ? 1 : 0;
-  const initialRecoveryAttempts = options.status === "QUEUED" ? 0 : 1;
-  const result = await db.insertInto("runs").values({
-    id: options.runId,
-    path: options.path,
-    workflow_name: options.workflowName,
-    status: options.status,
-    inputs: options.inputs,
-    idempotency_key: options.idempotencyKey,
-    executor_id: options.executorId,
-    parent_run_id: options.parentRunId,
-    timeout_ms: options.timeout,
-    deadline_epoch_ms: options.deadline,
-    recovery_attempts: initialRecoveryAttempts,
-    queue_name: options.queueName,
-    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).onConflict(
-    (oc) => oc.column("id").doUpdateSet({
-      recovery_attempts: sql`CASE 
-            WHEN runs.status != 'QUEUED' 
-            THEN runs.recovery_attempts + ${incrementAttempts}
-            ELSE runs.recovery_attempts
-          END`,
-      // Update executor_id when NEW status is not ENQUEUED
-      // This allows dequeue operations to claim the workflow
-      executor_id: sql`CASE 
-            WHEN EXCLUDED.status != 'QUEUED' 
-            THEN EXCLUDED.executor_id
-            ELSE runs.executor_id
-          END`,
-      updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-    })
-  ).returning([
-    "id",
-    "change_id",
-    "recovery_attempts",
-    "executor_id",
-    "idempotency_key",
-    "status",
-    "path"
-  ]).executeTakeFirst();
-  if (!result) {
-    throw new Error("Unexpectedly failed to upsert run");
-  }
-  const isOwner = result.idempotency_key === options.idempotencyKey;
-  const shouldExecute = isOwner || options.isRecovery;
-  if (shouldExecute) {
-    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
-    if (result.recovery_attempts > maxRetries + 1) {
-      await db.updateTable("runs").set({
-        status: "MAX_RECOVERY_ATTEMPTS_EXCEEDED",
-        updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-      }).where("id", "=", result.id).where("status", "=", "PENDING").execute();
-      throw new MaxRecoveryAttemptsExceededError(result.id, maxRetries);
-    }
-  }
-  return {
-    runId: result.id,
-    path: options.path,
-    changeId: result.change_id,
-    recoveryAttempts: result.recovery_attempts,
-    executorId: result.executor_id ?? void 0,
-    idempotencyKey: result.idempotency_key ?? void 0,
-    status: result.status,
-    shouldExecute: shouldExecute ?? false
-  };
-}
-
-// core/internal/recover-pending-runs.ts
-async function recoverPendingRuns(ctx) {
-  const { db, executorId, workflowRegistry } = ctx;
-  const pendingRuns = await getPendingRuns(db, executorId);
-  for (const run of pendingRuns) {
-    try {
-      const operations = await getOperations(db, run.id);
-      const workflow = workflowRegistry.getByName(run.workflowName);
-      if (!workflow) {
-        console.error(`Workflow ${run.workflowName} not found for recovery`);
-        continue;
-      }
-      const args = run.inputs ? deserialize(run.inputs) : [];
-      const upsertResult = await upsertRun(db, {
-        runId: run.id,
-        path: run.path,
-        inputs: run.inputs ?? "",
-        executorId,
-        workflowName: run.workflowName,
-        status: "PENDING" /* PENDING */,
-        isRecovery: true
-      });
-      if (!upsertResult.shouldExecute) {
-        console.log(`Run ${run.id} already executed, skipping recovery`);
-        continue;
-      }
-      await executeWorkflow(ctx, {
-        runId: upsertResult.runId,
-        runPath: upsertResult.path,
-        workflowName: run.workflowName,
-        fn: workflow.fn,
-        args,
-        operations
-      });
-    } catch (error) {
-      console.error(`Error recovering run ${run.id}:`, error);
-    }
-  }
-}
-
-// core/internal/workflow-registry.ts
-var WorkflowRegistry = class {
-  workflows = {};
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  fnToName = /* @__PURE__ */ new Map();
-  constructor(workflows) {
-    this.workflows = workflows;
-    for (const [name, entry] of Object.entries(workflows)) {
-      this.fnToName.set(entry, name);
-    }
-  }
-  getByName(name) {
-    const entry = this.workflows[name];
-    if (!entry) {
-      return void 0;
-    }
-    return {
-      ...entry(),
-      name
-    };
-  }
-  getByWorkflowDefinition(definition) {
-    const name = this.fnToName.get(definition);
-    if (!name) {
-      return void 0;
-    }
-    return {
-      ...definition(),
-      name
-    };
-  }
-};
-
-// core/internal/repository/get-run-batch.ts
-async function getRunBatch(db, runIds) {
-  const results = await db.selectFrom("runs").select(["id", "inputs", "output", "error", "status", "change_id", "queue_name"]).where("id", "in", runIds).execute();
-  return results.map((r) => ({
-    id: r.id,
-    input: r.inputs ?? void 0,
-    output: r.output ?? void 0,
-    error: r.error ?? void 0,
-    status: r.status,
-    changeId: r.change_id,
-    queueName: r.queue_name ?? void 0
-  }));
-}
-
-// core/internal/events/run-event-bus.ts
-var POLLING_FALLBACK_INTERVAL_MS3 = 1e4;
-var RunEventBus = class {
-  constructor(db) {
-    this.db = db;
-    this.pollingLoop = new PollingLoop(POLLING_FALLBACK_INTERVAL_MS3, this.handlePoll.bind(this));
-    this.bus = new EventBusCore({ allowWildcardSubscriptions: true }, this.pollingLoop);
-    this.pollingLoop.start();
-  }
-  bus;
-  pollingLoop;
-  handleNotify(payload) {
-    const [runId, status, changeIdString] = payload.split("::");
-    const changeId = Number(changeIdString);
-    if (!this.bus.checkHasSubscribers(runId, status) || this.bus.getEventSequence(runId, status) >= changeId) {
-      return;
-    }
-    getRun(this.db, runId).then((run) => {
-      if (!run) {
-        return;
-      }
-      this.bus.emitEvent(
-        runId,
-        status,
-        {
-          status: run.status,
-          queueName: run.queueName,
-          result: run.output,
-          error: run.error
-        },
-        changeId
-      );
-    });
-  }
-  async handlePoll() {
-    const workflowIds = [
-      ...new Set(this.bus.getSubscriptionKeys().map(([workflowId]) => workflowId))
-    ];
-    if (workflowIds.length === 0) {
-      return;
-    }
-    const runs = await getRunBatch(this.db, workflowIds);
-    for (const run of runs) {
-      this.bus.emitEvent(
-        run.id,
-        run.status,
-        {
-          status: run.status,
-          queueName: run.queueName,
-          result: run.output,
-          error: run.error
-        },
-        run.changeId
-      );
-    }
-  }
-  subscribe(runId, status, cb) {
-    return this.bus.subscribe(runId, status, cb);
-  }
-  destroy() {
-    this.pollingLoop.stop();
-  }
-};
-
-// core/internal/queue-registry.ts
-var QueueRegistry = class {
-  queues = {};
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
-  fnToName = /* @__PURE__ */ new Map();
-  constructor(queues) {
-    this.queues = queues;
-    for (const [name, entry] of Object.entries(queues)) {
-      this.fnToName.set(entry, name);
-    }
-  }
-  getByName(name) {
-    const entry = this.queues[name];
-    if (!entry) {
-      return void 0;
-    }
-    return {
-      name,
-      ...entry()
-    };
-  }
-  getByQueueEntry(entry) {
-    const name = this.fnToName.get(entry);
-    if (!name) {
-      return void 0;
-    }
-    return {
-      ...entry(),
-      name
-    };
-  }
-  getQueueInstances() {
-    return Object.entries(this.queues).reduce(
-      (acc, [name, entry]) => {
-        const options = entry();
-        acc[name] = {
-          rateLimit: options.rateLimit ?? void 0,
-          workerConcurrency: options.workerConcurrency ?? void 0,
-          concurrency: options.concurrency ?? void 0,
-          priorityEnabled: options.priorityEnabled ?? void 0
-        };
-        return acc;
-      },
-      {}
-    );
-  }
-};
-
-// client/cancel-run.ts
-async function cancelRun2(ctx, runId) {
-  const { db, runRegistry } = ctx;
-  const run = await cancelRun(runId, db);
-  if (!run) {
-    throw new RunNotFoundError(runId);
-  }
-  for (const pathPart of run.path) {
-    const run2 = runRegistry.getRun(pathPart);
-    if (run2) {
-      run2.abortController.abort();
-    }
-  }
-}
-async function enqueueRun(db, options) {
-  const result = await db.insertInto("runs").values({
-    id: options.runId,
-    path: options.path,
-    inputs: options.inputs,
-    queue_name: options.queueName,
-    queue_partition_key: options.queuePartitionKey,
-    queue_deduplication_id: options.deduplicationId,
-    executor_id: options.executorId,
-    workflow_name: options.workflowName,
-    status: "QUEUED" /* QUEUED */,
-    recovery_attempts: options.recoveryAttempts,
-    created_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).onConflict((oc) => oc.columns(["queue_name", "queue_deduplication_id"]).doNothing()).returning(["id", "change_id"]).executeTakeFirst();
-  return {
-    runId: result?.id,
-    changeId: result?.change_id
-  };
-}
-
-// client/queue-workflow.ts
-async function queueWorkflow(ctx, queue, wf, args, options) {
-  const { db, executorId, workflowRegistry, queueRegistry } = ctx;
-  const runId = crypto.randomUUID();
-  const workflowName = typeof wf === "string" ? wf : workflowRegistry.getByWorkflowDefinition(wf)?.name;
-  if (!workflowName) {
-    throw new WorkflowNotFoundError("Workflow name not specified");
-  }
-  const queueName = typeof queue === "string" ? queue : queueRegistry.getByQueueEntry(queue)?.name;
-  if (!queueName) {
-    throw new QueueNotFoundError("Queue name not specified");
-  }
-  await enqueueRun(db, {
-    runId,
-    path: [runId],
-    inputs: serialize(args),
-    executorId,
-    workflowName,
-    timeout: options?.timeout,
-    deadline: options?.deadline,
-    queueName
-  });
-  return createRunHandle(ctx, runId);
-}
-async function dequeueRun(tx, runId, executorId) {
-  const result = await tx.updateTable("runs").set({
-    status: "PENDING" /* PENDING */,
-    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`,
-    executor_id: executorId
-  }).where("id", "=", runId).where("status", "=", "QUEUED" /* QUEUED */).returning([
-    "id",
-    "change_id",
-    "path",
-    "timeout_ms",
-    "deadline_epoch_ms",
-    "inputs",
-    "workflow_name"
-  ]).executeTakeFirst();
-  if (!result) {
-    throw new RunNotFoundError(runId);
-  }
-  return {
-    runId: result.id,
-    changeId: result.change_id,
-    path: result.path,
-    timeoutMs: result.timeout_ms ? Number(result.timeout_ms) : void 0,
-    deadlineEpochMs: result.deadline_epoch_ms ? Number(result.deadline_epoch_ms) : void 0,
-    inputs: result.inputs ?? void 0,
-    workflowName: result.workflow_name
-  };
-}
-
-// core/internal/repository/get-executable-runs.ts
-async function getExecutableRuns(db, {
-  queueName,
-  executorId,
-  workerConcurrency,
-  globalConcurrency,
-  rateLimit,
-  partitionKey,
-  priorityEnabled
-}) {
-  const startTimeMs = Date.now();
-  const limiterPeriodMs = rateLimit ? rateLimit.period * 1e3 : 0;
-  return await withDbRetry(
-    async () => db.transaction().execute(async (tx) => {
-      if (rateLimit) {
-        const result = await tx.selectFrom("runs").select(({ fn }) => [fn.count("id").as("count")]).where("queue_name", "=", queueName).where("status", "!=", "QUEUED" /* QUEUED */).where("started_at_epoch_ms", ">", (startTimeMs - limiterPeriodMs).toString()).$if(
-          partitionKey !== void 0,
-          (qb) => qb.where("queue_partition_key", "=", partitionKey)
-        ).executeTakeFirstOrThrow();
-        if (result.count >= rateLimit.limitPerPeriod) {
-          return [];
-        }
-      }
-      let maxTasks = Infinity;
-      if (globalConcurrency || workerConcurrency) {
-        const runningTasks = await tx.selectFrom("runs").select(["executor_id", ({ fn }) => fn.count("id").as("task_count")]).where("queue_name", "=", queueName).where("status", "=", "PENDING" /* PENDING */).$if(
-          partitionKey !== void 0,
-          (qb) => qb.where("queue_partition_key", "=", partitionKey)
-        ).groupBy("executor_id").execute();
-        const tasksByExecutor = Object.fromEntries(
-          runningTasks.map((row) => [row.executor_id, row.task_count])
-        );
-        const runningForThisWorker = tasksByExecutor[executorId] ?? 0;
-        if (workerConcurrency !== void 0) {
-          maxTasks = Math.max(0, workerConcurrency - runningForThisWorker);
-        }
-        if (globalConcurrency !== void 0) {
-          const totalRunning = Object.values(tasksByExecutor).reduce((a, b) => a + b, 0);
-          const availableGlobal = Math.max(0, globalConcurrency - totalRunning);
-          maxTasks = Math.min(maxTasks, availableGlobal);
-        }
-        if (maxTasks <= 0) {
-          return [];
-        }
-      }
-      const lockClause = globalConcurrency ? "FOR UPDATE NOWAIT" : "FOR UPDATE SKIP LOCKED";
-      const workflowIds = await sql`
-        SELECT id 
-          FROM runs
-          WHERE status = ${"QUEUED" /* QUEUED */}
-          AND queue_name = ${queueName}
-          ${partitionKey !== void 0 ? sql`AND queue_partition_key = ${partitionKey}` : sql``}
-        ${priorityEnabled ? sql`ORDER BY priority ASC, created_at ASC` : sql`ORDER BY created_at ASC`}
-        ${maxTasks !== Infinity ? sql`LIMIT ${maxTasks}` : sql``}
-        ${sql.raw(lockClause)}
-      `.execute(tx);
-      const claimedRuns = [];
-      for (const { id } of workflowIds.rows) {
-        const dequeuedRun = await dequeueRun(tx, id, executorId);
-        claimedRuns.push(dequeuedRun);
-      }
-      return claimedRuns;
-    })
-  );
-}
-
-// core/internal/repository/get-queue-partitions.ts
-async function getQueuePartitions(db, queueName) {
-  const result = await db.selectFrom("runs").select("queue_partition_key").distinct().where("queue_name", "=", queueName).where("status", "=", "QUEUED" /* QUEUED */).where("queue_partition_key", "is not", null).execute();
-  return result.map((row) => row.queue_partition_key);
-}
-
-// core/internal/queue-manager.ts
-var POLLING_INTERVAL_MS = 1e3;
-var QueueManager = class {
-  constructor(ctx) {
-    this.ctx = ctx;
-    this.pollingLoop = new PollingLoop(POLLING_INTERVAL_MS, this.handlePoll.bind(this));
-    this.queues = this.ctx.queueRegistry.getQueueInstances();
-  }
-  pollingLoop;
-  queues = {};
-  async handlePoll() {
-    for (const [queueName, queue] of Object.entries(this.queues)) {
-      await this.dispatch(queueName, queue);
-    }
-  }
-  async dispatch(queueName, queue) {
-    const { db, executorId } = this.ctx;
-    let partitions = [];
-    if (queue.partitioningEnabled) {
-      partitions = await getQueuePartitions(db, queueName);
-      for (const partition of partitions) {
-        const runs2 = await getExecutableRuns(db, {
-          queueName,
-          executorId,
-          workerConcurrency: queue.workerConcurrency,
-          globalConcurrency: queue.concurrency,
-          rateLimit: queue.rateLimit,
-          partitionKey: partition,
-          priorityEnabled: queue.priorityEnabled
-        });
-        for (const run of runs2) {
-          const workflow = this.ctx.workflowRegistry.getByName(run.workflowName);
-          if (!workflow) {
-            console.error(`Workflow ${run.workflowName} not found`);
-            continue;
-          }
-          await executeWorkflow(this.ctx, {
-            runId: run.runId,
-            runPath: run.path,
-            workflowName: run.workflowName,
-            fn: workflow.fn,
-            args: deserialize(run.inputs ?? "[]")
-          });
-        }
-      }
-      return;
-    }
-    const runs = await getExecutableRuns(db, {
-      queueName,
-      executorId,
-      workerConcurrency: queue.workerConcurrency,
-      globalConcurrency: queue.concurrency,
-      rateLimit: queue.rateLimit,
-      priorityEnabled: queue.priorityEnabled
-    });
-    for (const run of runs) {
-      const workflow = this.ctx.workflowRegistry.getByName(run.workflowName);
-      if (!workflow) {
-        console.error(`Workflow ${run.workflowName} not found`);
-        continue;
-      }
-      await executeWorkflow(this.ctx, {
-        runId: run.runId,
-        runPath: run.path,
-        workflowName: run.workflowName,
-        fn: workflow.fn,
-        args: deserialize(run.inputs ?? "[]")
-      });
-    }
-  }
-  start() {
-    this.pollingLoop.start();
-  }
-  destroy() {
-    this.pollingLoop.stop();
-  }
-};
-
-// core/internal/events/setup-postgres-notify.ts
-var CHANNELS = ["runs", "messages", "state"];
-async function setupPostgresNotify(client, subscriptions) {
-  await withDbRetry(async () => {
-    try {
-      await client.query(`BEGIN`);
-      for (const channel of CHANNELS) {
-        await client.query(`LISTEN "helical_${channel}"`);
-      }
-      await client.query(`COMMIT`);
-    } catch (error) {
-      await client.query(`ROLLBACK`);
-      throw error;
-    }
-    for (const [channel, callback] of Object.entries(subscriptions)) {
-      await client.listen(`helical_${channel}`, callback);
-    }
-  });
-}
-function createPgDriver({ connectionString }) {
-  const pool = new Pool({
-    connectionString,
-    max: 10
-  });
-  let clientPromise;
-  const getClient = async () => {
-    if (!clientPromise) {
-      clientPromise = pool.connect();
-    }
-    return await clientPromise;
-  };
-  return {
-    client: {
-      listen: async (channel, callback) => {
-        const client = await getClient();
-        client.on("notification", (msg) => {
-          if (msg.channel !== channel) return;
-          callback(msg.payload);
-        });
-      },
-      query: async (query) => {
-        const client = await getClient();
-        await client.query(query);
-      }
-    },
-    db: new Kysely({ dialect: new PostgresDialect({ pool }) })
-  };
-}
-var INTERNAL_QUEUE_NAME = "_helical_internal_queue";
-async function resumeRun(db, runId) {
-  const result = await db.updateTable("runs").set({
-    status: "QUEUED" /* QUEUED */,
-    queue_name: INTERNAL_QUEUE_NAME,
-    deadline_epoch_ms: null,
-    timeout_ms: null,
-    recovery_attempts: 0,
-    started_at_epoch_ms: sql`(extract(epoch from now()) * 1000)::bigint`,
-    updated_at: sql`(extract(epoch from now()) * 1000)::bigint`
-  }).where("id", "=", runId).where("status", "=", "PENDING" /* PENDING */).execute();
-  if (!result) {
-    throw new RunNotFoundError(runId);
-  }
-}
-
-// client/resume-run.ts
-async function resumeRun2(ctx, runId) {
-  const { db } = ctx;
-  await resumeRun(db, runId);
-  return createRunHandle(ctx, runId);
-}
-
-// core/internal/repository/insert-message.ts
-async function insertMessage(db, options) {
-  return await db.insertInto("messages").values({
-    destination_run_id: options.destinationWorkflowId,
-    type: options.messageType,
-    payload: options.data
-  }).execute();
-}
-
-// client/send-message.ts
-async function sendMessage(ctx, target, name, data) {
-  const { db } = ctx;
-  const destinationWorkflowId = typeof target === "string" ? target : target.id;
-  const messageType = typeof name === "string" ? name : name.name;
-  const serializedData = serialize(data);
-  await insertMessage(db, {
-    destinationWorkflowId,
-    messageType,
-    data: serializedData
-  });
-}
-
-// client/get-state.ts
-var StateNotAvailableError = class extends Error {
-};
-async function getState2(ctx, target, key) {
-  const { db, stateEventBus } = ctx;
-  const destinationWorkflowId = typeof target === "string" ? target : target.id;
-  const stateKey = typeof key === "string" ? key : key.name;
-  while (true) {
-    try {
-      return await withDbRetry(async () => {
-        const state = await getState(db, destinationWorkflowId, stateKey);
-        if (!state) {
-          throw new StateNotAvailableError();
-        }
-        return deserialize(state);
-      });
-    } catch (error) {
-      if (error instanceof StateNotAvailableError) {
-        await waitForStateNotification(stateEventBus, destinationWorkflowId, stateKey);
-        continue;
-      }
-      throw error;
-    }
-  }
-}
-async function waitForStateNotification(stateEventBus, runId, key) {
-  return new Promise((resolve) => {
-    const unsubscribe = stateEventBus.subscribe(runId, key, (state) => {
-      unsubscribe();
-      resolve(state);
-    });
-  });
-}
-
-// client/runtime.ts
-function createInstance(props) {
-  const { db, client } = createPgDriver({ connectionString: props.options.connectionString });
-  const messageEventBus = new MessageEventBus(db);
-  const stateEventBus = new StateEventBus(db);
-  const executorId = props.options.instanceId || crypto.randomUUID();
-  const runRegistry = new RunRegistry();
-  const workflowRegistry = new WorkflowRegistry(props.workflows);
-  const runEventBus = new RunEventBus(db);
-  const queueRegistry = new QueueRegistry(props.queues || {});
-  const runtimeContext = {
-    db,
-    executorId,
-    messageEventBus,
-    stateEventBus,
-    runRegistry,
-    workflowRegistry,
-    runEventBus,
-    queueRegistry
-  };
-  const notifySetupPromise = setupPostgresNotify(client, {
-    runs: runEventBus.handleNotify.bind(runEventBus),
-    state: stateEventBus.handleNotify.bind(stateEventBus),
-    messages: messageEventBus.handleNotify.bind(messageEventBus)
-  });
-  const queueManager = new QueueManager(runtimeContext);
-  queueManager.start();
-  recoverPendingRuns(runtimeContext);
-  return {
-    runWorkflow: async (wf, args, options) => {
-      await notifySetupPromise;
-      return runWorkflow(runtimeContext, wf, args, options);
-    },
-    cancelRun: async (runId) => cancelRun2(runtimeContext, runId),
-    resumeRun: async (runId) => resumeRun2(runtimeContext, runId),
-    getRun: async (runId) => {
-      await notifySetupPromise;
-      return createRunHandle(runtimeContext, runId);
-    },
-    queueWorkflow: async (queue, wf, args, options) => {
-      await notifySetupPromise;
-      return queueWorkflow(runtimeContext, queue, wf, args, options);
-    },
-    sendMessage: async (target, name, data) => {
-      await notifySetupPromise;
-      return sendMessage(runtimeContext, target, name, data);
-    },
-    getState: async (target, key) => {
-      await notifySetupPromise;
-      return getState2(runtimeContext, target, key);
-    }
-  };
-}
-
-export { createInstance };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map