@shipfox/api-workflows 2.0.0

package/dist/db/db.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"db.d.ts","sourceRoot":"","sources":["../../src/db/db.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,cAAc,EAAC,MAAM,uBAAuB,CAAC;AAWnE,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CASlB,CAAC;AAIF,wBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGjB;AAED,wBAAgB,OAAO,IAAI,IAAI,CAE9B;AAED,MAAM,MAAM,EAAE,GAAG,UAAU,CAAC,UAAU,CAAC,cAAc,CAAC,OAAO,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAI5F,wBAAgB,eAAe,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAEzE"}

package/dist/db/db.js

@@ -0,0 +1,37 @@
+import { drizzle } from '@shipfox/node-drizzle';
+import { pgClient } from '@shipfox/node-postgres';
+import { jobExecutions } from './schema/job-executions.js';
+import { jobListenerEvents } from './schema/job-listener-events.js';
+import { jobs } from './schema/jobs.js';
+import { workflowsOutbox } from './schema/outbox.js';
+import { stepAttempts } from './schema/step-attempts.js';
+import { steps } from './schema/steps.js';
+import { workflowRunAttempts } from './schema/workflow-run-attempts.js';
+import { workflowRuns } from './schema/workflow-runs.js';
+export const schema = {
+    workflowRuns,
+    workflowRunAttempts,
+    jobs,
+    jobExecutions,
+    jobListenerEvents,
+    steps,
+    stepAttempts,
+    workflowsOutbox
+};
+let _db;
+export function db() {
+    if (!_db) _db = drizzle(pgClient(), {
+        schema
+    });
+    return _db;
+}
+export function closeDb() {
+    _db = undefined;
+}
+// Lets callers express a unit of work to run atomically without depending on the
+// db() singleton or drizzle's transaction API directly.
+export function withTransaction(fn) {
+    return db().transaction(fn);
+}
+
+//# sourceMappingURL=db.js.map

package/dist/db/db.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/db.ts"],"sourcesContent":["import {drizzle, type NodePgDatabase} from '@shipfox/node-drizzle';\nimport {pgClient} from '@shipfox/node-postgres';\nimport {jobExecutions} from './schema/job-executions.js';\nimport {jobListenerEvents} from './schema/job-listener-events.js';\nimport {jobs} from './schema/jobs.js';\nimport {workflowsOutbox} from './schema/outbox.js';\nimport {stepAttempts} from './schema/step-attempts.js';\nimport {steps} from './schema/steps.js';\nimport {workflowRunAttempts} from './schema/workflow-run-attempts.js';\nimport {workflowRuns} from './schema/workflow-runs.js';\n\nexport const schema = {\n  workflowRuns,\n  workflowRunAttempts,\n  jobs,\n  jobExecutions,\n  jobListenerEvents,\n  steps,\n  stepAttempts,\n  workflowsOutbox,\n};\n\nlet _db: NodePgDatabase<typeof schema> | undefined;\n\nexport function db() {\n  if (!_db) _db = drizzle(pgClient(), {schema});\n  return _db;\n}\n\nexport function closeDb(): void {\n  _db = undefined;\n}\n\nexport type Tx = Parameters<Parameters<NodePgDatabase<typeof schema>['transaction']>[0]>[0];\n\n// Lets callers express a unit of work to run atomically without depending on the\n// db() singleton or drizzle's transaction API directly.\nexport function withTransaction<T>(fn: (tx: Tx) => Promise<T>): Promise<T> {\n  return db().transaction(fn);\n}\n"],"names":["drizzle","pgClient","jobExecutions","jobListenerEvents","jobs","workflowsOutbox","stepAttempts","steps","workflowRunAttempts","workflowRuns","schema","_db","db","closeDb","undefined","withTransaction","fn","transaction"],"mappings":"AAAA,SAAQA,OAAO,QAA4B,wBAAwB;AACnE,SAAQC,QAAQ,QAAO,yBAAyB;AAChD,SAAQC,aAAa,QAAO,6BAA6B;AACzD,SAAQC,iBAAiB,QAAO,kCAAkC;AAClE,SAAQC,IAAI,QAAO,mBAAmB;AACtC,SAAQC,eAAe,QAAO,qBAAqB;AACnD,SAAQC,YAAY,QAAO,4BAA4B;AACvD,SAAQC,KAAK,QAAO,oBAAoB;AACxC,SAAQC,mBAAmB,QAAO,oCAAoC;AACtE,SAAQC,YAAY,QAAO,4BAA4B;AAEvD,OAAO,MAAMC,SAAS;IACpBD;IACAD;IACAJ;IACAF;IACAC;IACAI;IACAD;IACAD;AACF,EAAE;AAEF,IAAIM;AAEJ,OAAO,SAASC;IACd,IAAI,CAACD,KAAKA,MAAMX,QAAQC,YAAY;QAACS;IAAM;IAC3C,OAAOC;AACT;AAEA,OAAO,SAASE;IACdF,MAAMG;AACR;AAIA,iFAAiF;AACjF,wDAAwD;AACxD,OAAO,SAASC,gBAAmBC,EAA0B;IAC3D,OAAOJ,KAAKK,WAAW,CAACD;AAC1B"}

package/dist/db/index.d.ts

@@ -0,0 +1,9 @@
+export { closeDb, db, schema } from './db.js';
+export { type DeliverEventToListenerParams, type DeliverEventToListenerResult, deliverEventToListener, } from './job-listener-events.js';
+export type { ActivateJobListenerParams, ActivateJobListenerResult, DrainListenerEventsParams, DrainListenerEventsResult, ListenerBufferPeek, } from './job-listeners.js';
+export { activateJobListener, countActiveListeners, drainListenerEventsIntoExecution, peekListenerBuffer, resolveJobListener, settleListenerJobExecution, } from './job-listeners.js';
+export { workflowsOutbox } from './schema/outbox.js';
+export type { BulkUpdateStepStatusesParams, CancelWorkflowRunParams, CreateRerunWorkflowRunParams, CreateWorkflowRunParams, EvaluateJobActivationsParams, FailWorkflowRunAsTimedOutParams, JobActivationDecision, ListWorkflowRunsParams, ListWorkflowRunsResult, UpdateJobExecutionStatusParams, UpdateJobStatusParams, UpdateWorkflowRunStatusParams, WorkflowJobExecutionDepth, WorkflowJobExecutionDepthParams, WorkflowRunAggregates, WorkflowRunFilters, } from './workflow-runs.js';
+export { bulkUpdateStepStatuses, cancelWorkflowRun, createRerunWorkflowRun, createWorkflowRun, evaluateJobActivations, failJobExecutionAsTimedOut, failWorkflowRunAsTimedOut, getFirstJobExecutionByJobId, getJobById, getJobExecutionById, getJobExecutionDetail, getJobExecutionsByJobId, getJobExecutionsByWorkflowRunAttemptId, getJobScope, getJobsByWorkflowRunAttemptId, getJobsByWorkflowRunId, getLatestAttempt, getStepAttempts, getStepAttemptsByJobIds, getStepById, getStepByIdForJobExecution, getStepsByJobExecutionId, getStepsByJobExecutionIdForUpdate, getWorkflowJobExecutionDepth, getWorkflowRunAggregates, getWorkflowRunAttemptById, getWorkflowRunByAttemptId, getWorkflowRunById, getWorkflowRunDetail, listRunAttempts, listWorkflowRuns, listWorkflowRunsByProject, recordJobExecutionQueuedAt, recordJobExecutionStartedAt, resolveJobExecutionAfterLeaseExpiry, resolveJobStatusFromJobExecutions, updateJobExecutionStatus, updateJobStatus, updateWorkflowRunStatus, } from './workflow-runs.js';
+export declare const migrationsPath: string;
+//# sourceMappingURL=index.d.ts.map

package/dist/db/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/db/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,OAAO,EAAE,EAAE,EAAE,MAAM,EAAC,MAAM,SAAS,CAAC;AAC5C,OAAO,EACL,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,EACjC,sBAAsB,GACvB,MAAM,0BAA0B,CAAC;AAClC,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,mBAAmB,EACnB,oBAAoB,EACpB,gCAAgC,EAChC,kBAAkB,EAClB,kBAAkB,EAClB,0BAA0B,GAC3B,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,eAAe,EAAC,MAAM,oBAAoB,CAAC;AACnD,YAAY,EACV,4BAA4B,EAC5B,uBAAuB,EACvB,4BAA4B,EAC5B,uBAAuB,EACvB,4BAA4B,EAC5B,+BAA+B,EAC/B,qBAAqB,EACrB,sBAAsB,EACtB,sBAAsB,EACtB,8BAA8B,EAC9B,qBAAqB,EACrB,6BAA6B,EAC7B,yBAAyB,EACzB,+BAA+B,EAC/B,qBAAqB,EACrB,kBAAkB,GACnB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EACL,sBAAsB,EACtB,iBAAiB,EACjB,sBAAsB,EACtB,iBAAiB,EACjB,sBAAsB,EACtB,0BAA0B,EAC1B,yBAAyB,EACzB,2BAA2B,EAC3B,UAAU,EACV,mBAAmB,EACnB,qBAAqB,EACrB,uBAAuB,EACvB,sCAAsC,EACtC,WAAW,EACX,6BAA6B,EAC7B,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EACf,uBAAuB,EACvB,WAAW,EACX,0BAA0B,EAC1B,wBAAwB,EACxB,iCAAiC,EACjC,4BAA4B,EAC5B,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,gBAAgB,EAChB,yBAAyB,EACzB,0BAA0B,EAC1B,2BAA2B,EAC3B,mCAAmC,EACnC,iCAAiC,EACjC,wBAAwB,EACxB,eAAe,EACf,uBAAuB,GACxB,MAAM,oBAAoB,CAAC;AAE5B,eAAO,MAAM,cAAc,QAAoE,CAAC"}

package/dist/db/index.js

@@ -0,0 +1,10 @@
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export { closeDb, db, schema } from './db.js';
+export { deliverEventToListener } from './job-listener-events.js';
+export { activateJobListener, countActiveListeners, drainListenerEventsIntoExecution, peekListenerBuffer, resolveJobListener, settleListenerJobExecution } from './job-listeners.js';
+export { workflowsOutbox } from './schema/outbox.js';
+export { bulkUpdateStepStatuses, cancelWorkflowRun, createRerunWorkflowRun, createWorkflowRun, evaluateJobActivations, failJobExecutionAsTimedOut, failWorkflowRunAsTimedOut, getFirstJobExecutionByJobId, getJobById, getJobExecutionById, getJobExecutionDetail, getJobExecutionsByJobId, getJobExecutionsByWorkflowRunAttemptId, getJobScope, getJobsByWorkflowRunAttemptId, getJobsByWorkflowRunId, getLatestAttempt, getStepAttempts, getStepAttemptsByJobIds, getStepById, getStepByIdForJobExecution, getStepsByJobExecutionId, getStepsByJobExecutionIdForUpdate, getWorkflowJobExecutionDepth, getWorkflowRunAggregates, getWorkflowRunAttemptById, getWorkflowRunByAttemptId, getWorkflowRunById, getWorkflowRunDetail, listRunAttempts, listWorkflowRuns, listWorkflowRunsByProject, recordJobExecutionQueuedAt, recordJobExecutionStartedAt, resolveJobExecutionAfterLeaseExpiry, resolveJobStatusFromJobExecutions, updateJobExecutionStatus, updateJobStatus, updateWorkflowRunStatus } from './workflow-runs.js';
+export const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');
+
+//# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/index.ts"],"sourcesContent":["import {dirname, resolve} from 'node:path';\nimport {fileURLToPath} from 'node:url';\n\nexport {closeDb, db, schema} from './db.js';\nexport {\n  type DeliverEventToListenerParams,\n  type DeliverEventToListenerResult,\n  deliverEventToListener,\n} from './job-listener-events.js';\nexport type {\n  ActivateJobListenerParams,\n  ActivateJobListenerResult,\n  DrainListenerEventsParams,\n  DrainListenerEventsResult,\n  ListenerBufferPeek,\n} from './job-listeners.js';\nexport {\n  activateJobListener,\n  countActiveListeners,\n  drainListenerEventsIntoExecution,\n  peekListenerBuffer,\n  resolveJobListener,\n  settleListenerJobExecution,\n} from './job-listeners.js';\nexport {workflowsOutbox} from './schema/outbox.js';\nexport type {\n  BulkUpdateStepStatusesParams,\n  CancelWorkflowRunParams,\n  CreateRerunWorkflowRunParams,\n  CreateWorkflowRunParams,\n  EvaluateJobActivationsParams,\n  FailWorkflowRunAsTimedOutParams,\n  JobActivationDecision,\n  ListWorkflowRunsParams,\n  ListWorkflowRunsResult,\n  UpdateJobExecutionStatusParams,\n  UpdateJobStatusParams,\n  UpdateWorkflowRunStatusParams,\n  WorkflowJobExecutionDepth,\n  WorkflowJobExecutionDepthParams,\n  WorkflowRunAggregates,\n  WorkflowRunFilters,\n} from './workflow-runs.js';\nexport {\n  bulkUpdateStepStatuses,\n  cancelWorkflowRun,\n  createRerunWorkflowRun,\n  createWorkflowRun,\n  evaluateJobActivations,\n  failJobExecutionAsTimedOut,\n  failWorkflowRunAsTimedOut,\n  getFirstJobExecutionByJobId,\n  getJobById,\n  getJobExecutionById,\n  getJobExecutionDetail,\n  getJobExecutionsByJobId,\n  getJobExecutionsByWorkflowRunAttemptId,\n  getJobScope,\n  getJobsByWorkflowRunAttemptId,\n  getJobsByWorkflowRunId,\n  getLatestAttempt,\n  getStepAttempts,\n  getStepAttemptsByJobIds,\n  getStepById,\n  getStepByIdForJobExecution,\n  getStepsByJobExecutionId,\n  getStepsByJobExecutionIdForUpdate,\n  getWorkflowJobExecutionDepth,\n  getWorkflowRunAggregates,\n  getWorkflowRunAttemptById,\n  getWorkflowRunByAttemptId,\n  getWorkflowRunById,\n  getWorkflowRunDetail,\n  listRunAttempts,\n  listWorkflowRuns,\n  listWorkflowRunsByProject,\n  recordJobExecutionQueuedAt,\n  recordJobExecutionStartedAt,\n  resolveJobExecutionAfterLeaseExpiry,\n  resolveJobStatusFromJobExecutions,\n  updateJobExecutionStatus,\n  updateJobStatus,\n  updateWorkflowRunStatus,\n} from './workflow-runs.js';\n\nexport const migrationsPath = resolve(dirname(fileURLToPath(import.meta.url)), '../../drizzle');\n"],"names":["dirname","resolve","fileURLToPath","closeDb","db","schema","deliverEventToListener","activateJobListener","countActiveListeners","drainListenerEventsIntoExecution","peekListenerBuffer","resolveJobListener","settleListenerJobExecution","workflowsOutbox","bulkUpdateStepStatuses","cancelWorkflowRun","createRerunWorkflowRun","createWorkflowRun","evaluateJobActivations","failJobExecutionAsTimedOut","failWorkflowRunAsTimedOut","getFirstJobExecutionByJobId","getJobById","getJobExecutionById","getJobExecutionDetail","getJobExecutionsByJobId","getJobExecutionsByWorkflowRunAttemptId","getJobScope","getJobsByWorkflowRunAttemptId","getJobsByWorkflowRunId","getLatestAttempt","getStepAttempts","getStepAttemptsByJobIds","getStepById","getStepByIdForJobExecution","getStepsByJobExecutionId","getStepsByJobExecutionIdForUpdate","getWorkflowJobExecutionDepth","getWorkflowRunAggregates","getWorkflowRunAttemptById","getWorkflowRunByAttemptId","getWorkflowRunById","getWorkflowRunDetail","listRunAttempts","listWorkflowRuns","listWorkflowRunsByProject","recordJobExecutionQueuedAt","recordJobExecutionStartedAt","resolveJobExecutionAfterLeaseExpiry","resolveJobStatusFromJobExecutions","updateJobExecutionStatus","updateJobStatus","updateWorkflowRunStatus","migrationsPath","url"],"mappings":"AAAA,SAAQA,OAAO,EAAEC,OAAO,QAAO,YAAY;AAC3C,SAAQC,aAAa,QAAO,WAAW;AAEvC,SAAQC,OAAO,EAAEC,EAAE,EAAEC,MAAM,QAAO,UAAU;AAC5C,SAGEC,sBAAsB,QACjB,2BAA2B;AAQlC,SACEC,mBAAmB,EACnBC,oBAAoB,EACpBC,gCAAgC,EAChCC,kBAAkB,EAClBC,kBAAkB,EAClBC,0BAA0B,QACrB,qBAAqB;AAC5B,SAAQC,eAAe,QAAO,qBAAqB;AAmBnD,SACEC,sBAAsB,EACtBC,iBAAiB,EACjBC,sBAAsB,EACtBC,iBAAiB,EACjBC,sBAAsB,EACtBC,0BAA0B,EAC1BC,yBAAyB,EACzBC,2BAA2B,EAC3BC,UAAU,EACVC,mBAAmB,EACnBC,qBAAqB,EACrBC,uBAAuB,EACvBC,sCAAsC,EACtCC,WAAW,EACXC,6BAA6B,EAC7BC,sBAAsB,EACtBC,gBAAgB,EAChBC,eAAe,EACfC,uBAAuB,EACvBC,WAAW,EACXC,0BAA0B,EAC1BC,wBAAwB,EACxBC,iCAAiC,EACjCC,4BAA4B,EAC5BC,wBAAwB,EACxBC,yBAAyB,EACzBC,yBAAyB,EACzBC,kBAAkB,EAClBC,oBAAoB,EACpBC,eAAe,EACfC,gBAAgB,EAChBC,yBAAyB,EACzBC,0BAA0B,EAC1BC,2BAA2B,EAC3BC,mCAAmC,EACnCC,iCAAiC,EACjCC,wBAAwB,EACxBC,eAAe,EACfC,uBAAuB,QAClB,qBAAqB;AAE5B,OAAO,MAAMC,iBAAiBpD,QAAQD,QAAQE,cAAc,YAAYoD,GAAG,IAAI,iBAAiB"}

package/dist/db/job-listener-events.d.ts

@@ -0,0 +1,18 @@
+import type { JobListenerEventDisposition } from '#core/entities/job-listener-event.js';
+export interface DeliverEventToListenerParams {
+    jobId: string;
+    disposition: JobListenerEventDisposition;
+    eventRef: string;
+    deliveryId: string;
+    source: string;
+    event: string;
+    provider: string;
+    payload: unknown;
+    receivedAt: Date;
+}
+export interface DeliverEventToListenerResult {
+    buffered: boolean;
+    skipped: boolean;
+}
+export declare function deliverEventToListener(params: DeliverEventToListenerParams): Promise<DeliverEventToListenerResult>;
+//# sourceMappingURL=job-listener-events.d.ts.map

package/dist/db/job-listener-events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-listener-events.d.ts","sourceRoot":"","sources":["../../src/db/job-listener-events.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,2BAA2B,EAAC,MAAM,sCAAsC,CAAC;AAOtF,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,2BAA2B,CAAC;IACzC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,UAAU,EAAE,IAAI,CAAC;CAClB;AAED,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,EAAE,4BAA4B,GACnC,OAAO,CAAC,4BAA4B,CAAC,CA2CvC"}

package/dist/db/job-listener-events.js

@@ -0,0 +1,59 @@
+import { WORKFLOWS_JOB_EVENT_DELIVERED } from '@shipfox/api-workflows-dto';
+import { eq } from 'drizzle-orm';
+import { isJobTerminal } from '#core/entities/job.js';
+import { recordListenerEventReceived } from '#metrics/instance.js';
+import { db } from './db.js';
+import { writeWorkflowsOutboxEvent } from './outbox-writes.js';
+import { jobListenerEvents } from './schema/job-listener-events.js';
+import { jobs } from './schema/jobs.js';
+export async function deliverEventToListener(params) {
+    const result = await db().transaction(async (tx)=>{
+        const [job] = await tx.select({
+            id: jobs.id,
+            status: jobs.status
+        }).from(jobs).where(eq(jobs.id, params.jobId)).for('update').limit(1);
+        if (!job || isJobTerminal(job.status)) return {
+            buffered: false,
+            skipped: true
+        };
+        const rows = await tx.insert(jobListenerEvents).values({
+            jobId: params.jobId,
+            disposition: params.disposition,
+            eventRef: params.eventRef,
+            deliveryId: params.deliveryId,
+            source: params.source,
+            event: params.event,
+            payload: params.payload,
+            receivedAt: params.receivedAt
+        }).onConflictDoNothing({
+            target: [
+                jobListenerEvents.jobId,
+                jobListenerEvents.eventRef
+            ]
+        }).returning({
+            id: jobListenerEvents.id
+        });
+        if (!rows[0]) return {
+            buffered: false,
+            skipped: false
+        };
+        await writeWorkflowsOutboxEvent(tx, {
+            type: WORKFLOWS_JOB_EVENT_DELIVERED,
+            payload: {
+                jobId: params.jobId,
+                disposition: params.disposition,
+                eventRef: params.eventRef,
+                eventName: params.event
+            }
+        });
+        return {
+            buffered: true,
+            skipped: false
+        };
+    });
+    if (!result.buffered) return result;
+    recordListenerEventReceived(params.provider);
+    return result;
+}
+
+//# sourceMappingURL=job-listener-events.js.map

package/dist/db/job-listener-events.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/db/job-listener-events.ts"],"sourcesContent":["import {WORKFLOWS_JOB_EVENT_DELIVERED} from '@shipfox/api-workflows-dto';\nimport {eq} from 'drizzle-orm';\nimport {isJobTerminal} from '#core/entities/job.js';\nimport type {JobListenerEventDisposition} from '#core/entities/job-listener-event.js';\nimport {recordListenerEventReceived} from '#metrics/instance.js';\nimport {db} from './db.js';\nimport {writeWorkflowsOutboxEvent} from './outbox-writes.js';\nimport {jobListenerEvents} from './schema/job-listener-events.js';\nimport {jobs} from './schema/jobs.js';\n\nexport interface DeliverEventToListenerParams {\n  jobId: string;\n  disposition: JobListenerEventDisposition;\n  eventRef: string;\n  deliveryId: string;\n  source: string;\n  event: string;\n  provider: string;\n  payload: unknown;\n  receivedAt: Date;\n}\n\nexport interface DeliverEventToListenerResult {\n  buffered: boolean;\n  skipped: boolean;\n}\n\nexport async function deliverEventToListener(\n  params: DeliverEventToListenerParams,\n): Promise<DeliverEventToListenerResult> {\n  const result = await db().transaction(async (tx) => {\n    const [job] = await tx\n      .select({id: jobs.id, status: jobs.status})\n      .from(jobs)\n      .where(eq(jobs.id, params.jobId))\n      .for('update')\n      .limit(1);\n\n    if (!job || isJobTerminal(job.status)) return {buffered: false, skipped: true};\n\n    const rows = await tx\n      .insert(jobListenerEvents)\n      .values({\n        jobId: params.jobId,\n        disposition: params.disposition,\n        eventRef: params.eventRef,\n        deliveryId: params.deliveryId,\n        source: params.source,\n        event: params.event,\n        payload: params.payload,\n        receivedAt: params.receivedAt,\n      })\n      .onConflictDoNothing({target: [jobListenerEvents.jobId, jobListenerEvents.eventRef]})\n      .returning({id: jobListenerEvents.id});\n\n    if (!rows[0]) return {buffered: false, skipped: false};\n    await writeWorkflowsOutboxEvent(tx, {\n      type: WORKFLOWS_JOB_EVENT_DELIVERED,\n      payload: {\n        jobId: params.jobId,\n        disposition: params.disposition,\n        eventRef: params.eventRef,\n        eventName: params.event,\n      },\n    });\n    return {buffered: true, skipped: false};\n  });\n\n  if (!result.buffered) return result;\n\n  recordListenerEventReceived(params.provider);\n  return result;\n}\n"],"names":["WORKFLOWS_JOB_EVENT_DELIVERED","eq","isJobTerminal","recordListenerEventReceived","db","writeWorkflowsOutboxEvent","jobListenerEvents","jobs","deliverEventToListener","params","result","transaction","tx","job","select","id","status","from","where","jobId","for","limit","buffered","skipped","rows","insert","values","disposition","eventRef","deliveryId","source","event","payload","receivedAt","onConflictDoNothing","target","returning","type","eventName","provider"],"mappings":"AAAA,SAAQA,6BAA6B,QAAO,6BAA6B;AACzE,SAAQC,EAAE,QAAO,cAAc;AAC/B,SAAQC,aAAa,QAAO,wBAAwB;AAEpD,SAAQC,2BAA2B,QAAO,uBAAuB;AACjE,SAAQC,EAAE,QAAO,UAAU;AAC3B,SAAQC,yBAAyB,QAAO,qBAAqB;AAC7D,SAAQC,iBAAiB,QAAO,kCAAkC;AAClE,SAAQC,IAAI,QAAO,mBAAmB;AAmBtC,OAAO,eAAeC,uBACpBC,MAAoC;IAEpC,MAAMC,SAAS,MAAMN,KAAKO,WAAW,CAAC,OAAOC;QAC3C,MAAM,CAACC,IAAI,GAAG,MAAMD,GACjBE,MAAM,CAAC;YAACC,IAAIR,KAAKQ,EAAE;YAAEC,QAAQT,KAAKS,MAAM;QAAA,GACxCC,IAAI,CAACV,MACLW,KAAK,CAACjB,GAAGM,KAAKQ,EAAE,EAAEN,OAAOU,KAAK,GAC9BC,GAAG,CAAC,UACJC,KAAK,CAAC;QAET,IAAI,CAACR,OAAOX,cAAcW,IAAIG,MAAM,GAAG,OAAO;YAACM,UAAU;YAAOC,SAAS;QAAI;QAE7E,MAAMC,OAAO,MAAMZ,GAChBa,MAAM,CAACnB,mBACPoB,MAAM,CAAC;YACNP,OAAOV,OAAOU,KAAK;YACnBQ,aAAalB,OAAOkB,WAAW;YAC/BC,UAAUnB,OAAOmB,QAAQ;YACzBC,YAAYpB,OAAOoB,UAAU;YAC7BC,QAAQrB,OAAOqB,MAAM;YACrBC,OAAOtB,OAAOsB,KAAK;YACnBC,SAASvB,OAAOuB,OAAO;YACvBC,YAAYxB,OAAOwB,UAAU;QAC/B,GACCC,mBAAmB,CAAC;YAACC,QAAQ;gBAAC7B,kBAAkBa,KAAK;gBAAEb,kBAAkBsB,QAAQ;aAAC;QAAA,GAClFQ,SAAS,CAAC;YAACrB,IAAIT,kBAAkBS,EAAE;QAAA;QAEtC,IAAI,CAACS,IAAI,CAAC,EAAE,EAAE,OAAO;YAACF,UAAU;YAAOC,SAAS;QAAK;QACrD,MAAMlB,0BAA0BO,IAAI;YAClCyB,MAAMrC;YACNgC,SAAS;gBACPb,OAAOV,OAAOU,KAAK;gBACnBQ,aAAalB,OAAOkB,WAAW;gBAC/BC,UAAUnB,OAAOmB,QAAQ;gBACzBU,WAAW7B,OAAOsB,KAAK;YACzB;QACF;QACA,OAAO;YAACT,UAAU;YAAMC,SAAS;QAAK;IACxC;IAEA,IAAI,CAACb,OAAOY,QAAQ,EAAE,OAAOZ;IAE7BP,4BAA4BM,OAAO8B,QAAQ;IAC3C,OAAO7B;AACT"}

package/dist/db/job-listeners.d.ts

@@ -0,0 +1,55 @@
+import type { AgentDefaultsResolver } from '@shipfox/api-agent/core/resolve-agent-config';
+import { type JobStatus, type ResolutionReason } from '#core/entities/job.js';
+import type { JobExecutionStatus } from '#core/entities/job-execution.js';
+export interface ActivateJobListenerParams {
+    jobId: string;
+    expectedVersion: number;
+}
+export interface ActivateJobListenerResult {
+    status: 'running' | 'terminal';
+    jobStatus: JobStatus;
+    jobVersion: number;
+    executionCount: number;
+}
+export declare function activateJobListener(params: ActivateJobListenerParams): Promise<ActivateJobListenerResult>;
+export type DrainListenerEventsResult = {
+    kind: 'execution';
+    jobExecutionId: string;
+    executionVersion: number;
+    sequence: number;
+    requiredLabels: string[];
+    status: JobExecutionStatus;
+} | {
+    kind: 'resolve-requested';
+} | {
+    kind: 'empty';
+};
+export interface DrainListenerEventsParams {
+    jobId: string;
+    expectedSequence: number;
+    maxSize?: number | undefined;
+    resolveAgentDefaults?: AgentDefaultsResolver | undefined;
+}
+export declare function drainListenerEventsIntoExecution(params: DrainListenerEventsParams): Promise<DrainListenerEventsResult>;
+export interface ListenerBufferPeek {
+    fireCount: number;
+    resolvePending: boolean;
+    oldestAgeMs: number;
+    newestAgeMs: number;
+}
+export declare function peekListenerBuffer(params: {
+    jobId: string;
+}): Promise<ListenerBufferPeek>;
+export declare function resolveJobListener(params: {
+    jobId: string;
+    reason: ResolutionReason;
+}): Promise<{
+    status: 'succeeded' | 'failed';
+    jobVersion: number;
+}>;
+export declare function settleListenerJobExecution(params: {
+    jobExecutionId: string;
+    status: Extract<JobExecutionStatus, 'failed' | 'cancelled'>;
+}): Promise<void>;
+export declare function countActiveListeners(): Promise<number>;
+//# sourceMappingURL=job-listeners.d.ts.map

package/dist/db/job-listeners.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-listeners.d.ts","sourceRoot":"","sources":["../../src/db/job-listeners.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,qBAAqB,EAAC,MAAM,8CAA8C,CAAC;AAOxF,OAAO,EAAgB,KAAK,SAAS,EAAE,KAAK,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAC3F,OAAO,KAAK,EAAC,kBAAkB,EAAyB,MAAM,iCAAiC,CAAC;AAkChG,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,yBAAyB;IACxC,MAAM,EAAE,SAAS,GAAG,UAAU,CAAC;IAC/B,SAAS,EAAE,SAAS,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,CAAC;CACxB;AAeD,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,yBAAyB,CAAC,CAyFpC;AAED,MAAM,MAAM,yBAAyB,GACjC;IACE,IAAI,EAAE,WAAW,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,MAAM,EAAE,kBAAkB,CAAC;CAC5B,GACD;IAAC,IAAI,EAAE,mBAAmB,CAAA;CAAC,GAC3B;IAAC,IAAI,EAAE,OAAO,CAAA;CAAC,CAAC;AAEpB,MAAM,WAAW,yBAAyB;IACxC,KAAK,EAAE,MAAM,CAAC;IACd,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,oBAAoB,CAAC,EAAE,qBAAqB,GAAG,SAAS,CAAC;CAC1D;AAED,wBAAsB,gCAAgC,CACpD,MAAM,EAAE,yBAAyB,GAChC,OAAO,CAAC,yBAAyB,CAAC,CAqDpC;AAED,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAsB7F;AAED,wBAAsB,kBAAkB,CAAC,MAAM,EAAE;IAC/C,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,gBAAgB,CAAC;CAC1B,GAAG,OAAO,CAAC;IAAC,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAAC,CAchE;AAwFD,wBAAsB,0BAA0B,CAAC,MAAM,EAAE;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,OAAO,CAAC,kBAAkB,EAAE,QAAQ,GAAG,WAAW,CAAC,CAAC;CAC7D,GAAG,OAAO,CAAC,IAAI,CAAC,CA6BhB;AAED,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAM5D"}

package/dist/db/job-listeners.js

@@ -0,0 +1,358 @@
+import { WORKFLOWS_JOB_ACTIVATED } from '@shipfox/api-workflows-dto';
+import { and, asc, count, eq, inArray, isNull, notInArray, sql } from 'drizzle-orm';
+import { loadAgentToolMaterializationContext } from '#core/agent-tools.js';
+import { isJobTerminal } from '#core/entities/job.js';
+import { deriveJobSuccess } from '#core/job-transition/index.js';
+import { materializeListenerExecution } from '#core/listener-execution-materialization.js';
+import { applyListenerFilterSnapshots, assembleListenerSnapshotContext, planListenerFilterSnapshots } from '#core/step-config/assemble-run-context.js';
+import { recordListenerEventsCoalesced, recordWorkflowJobExecutionStatusChanged, recordWorkflowListenerResolved } from '#metrics/instance.js';
+import { db } from './db.js';
+import { writeWorkflowsOutboxEvent } from './outbox-writes.js';
+import { jobExecutions, toJobExecution } from './schema/job-executions.js';
+import { jobListenerEvents } from './schema/job-listener-events.js';
+import { jobs, toJob } from './schema/jobs.js';
+import { steps } from './schema/steps.js';
+import { workflowRunAttempts } from './schema/workflow-run-attempts.js';
+import { toWorkflowRun, workflowRuns } from './schema/workflow-runs.js';
+import { bulkUpdateStepStatuses, getDirectDependencyJobContexts, updateJobStatusAtVersion } from './workflow-runs.js';
+const TERMINAL_EXECUTION_STATUSES = [
+    'succeeded',
+    'failed',
+    'cancelled'
+];
+const MAX_LISTENER_RESOLUTION_ATTEMPTS = 3;
+function applyActivatedListenerFilterSnapshots(plans, context) {
+    return applyListenerFilterSnapshots(plans, context);
+}
+export async function activateJobListener(params) {
+    return await db().transaction(async (tx)=>{
+        const [target] = await tx.select({
+            job: jobs,
+            run: workflowRuns
+        }).from(jobs).innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id)).innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id)).where(eq(jobs.id, params.jobId)).limit(1).for('update');
+        if (!target) throw new Error(`Job not found: ${params.jobId}`);
+        const [{ value: executionCount } = {
+            value: 0
+        }] = await tx.select({
+            value: count()
+        }).from(jobExecutions).where(eq(jobExecutions.jobId, params.jobId));
+        if ([
+            'succeeded',
+            'failed',
+            'cancelled',
+            'skipped'
+        ].includes(target.job.status)) {
+            return {
+                status: 'terminal',
+                jobStatus: target.job.status,
+                jobVersion: target.job.version,
+                executionCount
+            };
+        }
+        let job = toJob(target.job);
+        if (target.job.status === 'pending') {
+            const updated = await updateJobStatusAtVersion(tx, {
+                jobId: params.jobId,
+                status: 'running',
+                expectedVersion: params.expectedVersion
+            });
+            if (!updated) {
+                const [existing] = await tx.select().from(jobs).where(eq(jobs.id, params.jobId)).limit(1);
+                if (existing?.status !== 'running') {
+                    throw new Error(`Optimistic lock failure activating listener job ${params.jobId} version ${params.expectedVersion}`);
+                }
+                job = toJob(existing);
+            } else {
+                job = updated.job;
+            }
+        }
+        const listenerRows = await tx.update(jobs).set({
+            listenerStatus: 'listening',
+            updatedAt: new Date()
+        }).where(and(eq(jobs.id, params.jobId), eq(jobs.listenerStatus, 'inactive'))).returning();
+        if (listenerRows[0]) {
+            const matchers = {
+                on: target.job.listeningOn ?? [],
+                until: target.job.listeningUntil ?? null
+            };
+            const snapshotPlan = planListenerFilterSnapshots(matchers);
+            const dependencyJobs = snapshotPlan.jobKeys.size === 0 ? [] : await getDirectDependencyJobContexts(params.jobId, tx);
+            const snapshotContext = assembleListenerSnapshotContext({
+                job: toJob(target.job),
+                run: toWorkflowRun(target.run),
+                triggerPayload: target.run.triggerPayload,
+                inputs: target.run.inputs,
+                plan: snapshotPlan,
+                dependencyJobs
+            });
+            await writeWorkflowsOutboxEvent(tx, {
+                type: WORKFLOWS_JOB_ACTIVATED,
+                payload: {
+                    jobId: params.jobId,
+                    workflowRunId: target.run.id,
+                    workspaceId: target.run.workspaceId,
+                    mode: 'listening',
+                    on: applyActivatedListenerFilterSnapshots(snapshotPlan.on, snapshotContext),
+                    until: matchers.until === null ? null : applyActivatedListenerFilterSnapshots(snapshotPlan.until, snapshotContext)
+                }
+            });
+        }
+        return {
+            status: 'running',
+            jobStatus: job.status,
+            jobVersion: job.version,
+            executionCount
+        };
+    });
+}
+export async function drainListenerEventsIntoExecution(params) {
+    const drained = await db().transaction(async (tx)=>{
+        const existing = await findExistingExecution(params, tx);
+        if (existing) return {
+            result: existing
+        };
+        const resolveRequested = await hasPendingResolveEvent(params.jobId, tx);
+        if (resolveRequested) return {
+            result: {
+                kind: 'resolve-requested'
+            }
+        };
+        const bufferedEvents = await lockBufferedFireEvents(params, tx);
+        if (bufferedEvents.length === 0) return {
+            result: {
+                kind: 'empty'
+            }
+        };
+        const target = await loadListenerMaterializationTarget(params.jobId, tx);
+        const agentToolContext = target.attempt.agentToolMaterialization === null ? await loadAgentToolMaterializationContext({
+            model: target.attempt.model,
+            workspaceId: target.run.workspaceId,
+            projectId: target.run.projectId
+        }) : undefined;
+        const materialized = materializeListenerExecution({
+            model: target.attempt.model,
+            run: toWorkflowRun(target.run),
+            job: toJob(target.job),
+            sequence: params.expectedSequence,
+            triggerEvents: listenerTriggerEvents(bufferedEvents),
+            priorExecutions: target.priorExecutions,
+            resolveAgentDefaults: params.resolveAgentDefaults,
+            agentToolContext,
+            agentToolSnapshot: target.attempt.agentToolMaterialization
+        });
+        const execution = await persistMaterializedListenerExecution(tx, {
+            jobId: params.jobId,
+            sequence: params.expectedSequence,
+            bufferedEventIds: bufferedEvents.map((event)=>event.id),
+            materialized
+        });
+        if (materialized.status === 'failed') {
+            recordWorkflowJobExecutionStatusChanged(materialized.status);
+        }
+        return {
+            result: drainExecutionResult(execution),
+            batchSize: bufferedEvents.length
+        };
+    });
+    if (drained.result.kind === 'execution' && drained.batchSize !== undefined) {
+        recordListenerEventsCoalesced(drained.batchSize);
+    }
+    return drained.result;
+}
+export async function peekListenerBuffer(params) {
+    const [row] = await db().select({
+        fireCount: sql`count(*) filter (where ${jobListenerEvents.disposition} = 'fire')::integer`,
+        resolvePending: sql`coalesce(bool_or(${jobListenerEvents.disposition} = 'resolve'), false)`,
+        oldestAgeMs: sql`coalesce(floor(extract(epoch from (statement_timestamp() - min(${jobListenerEvents.receivedAt}) filter (where ${jobListenerEvents.disposition} = 'fire'))) * 1000), 0)::integer`,
+        newestAgeMs: sql`coalesce(floor(extract(epoch from (statement_timestamp() - max(${jobListenerEvents.receivedAt}) filter (where ${jobListenerEvents.disposition} = 'fire'))) * 1000), 0)::integer`
+    }).from(jobListenerEvents).where(and(eq(jobListenerEvents.jobId, params.jobId), isNull(jobListenerEvents.consumedByExecutionId)));
+    return {
+        fireCount: row?.fireCount ?? 0,
+        resolvePending: row?.resolvePending ?? false,
+        oldestAgeMs: row?.oldestAgeMs ?? 0,
+        newestAgeMs: row?.newestAgeMs ?? 0
+    };
+}
+export async function resolveJobListener(params) {
+    let result;
+    for(let attempt = 0; attempt < MAX_LISTENER_RESOLUTION_ATTEMPTS; attempt += 1){
+        const decision = await deriveJobListenerResolutionDecision(params.jobId);
+        result = await applyJobListenerResolution(params, decision);
+        if (result.kind === 'applied') break;
+    }
+    if (result?.kind !== 'applied') {
+        throw new Error(`Optimistic lock failure resolving listener job ${params.jobId}`);
+    }
+    if (result.changed) recordWorkflowListenerResolved(params.reason);
+    return {
+        status: result.status,
+        jobVersion: result.jobVersion
+    };
+}
+async function deriveJobListenerResolutionDecision(jobId) {
+    const [jobRow] = await db().select().from(jobs).where(eq(jobs.id, jobId)).limit(1);
+    if (!jobRow) throw new Error(`Job not found: ${jobId}`);
+    const [executionRows, dependencyJobs] = await Promise.all([
+        db().select().from(jobExecutions).where(eq(jobExecutions.jobId, jobId)).orderBy(asc(jobExecutions.sequence), asc(jobExecutions.id)),
+        getDirectDependencyJobContexts(jobId)
+    ]);
+    return {
+        expectedVersion: jobRow.version,
+        ...deriveJobSuccess({
+            success: jobRow.success,
+            executions: executionRows.map(toJobExecution),
+            jobs: dependencyJobs
+        })
+    };
+}
+async function applyJobListenerResolution(params, decision) {
+    return await db().transaction(async (tx)=>{
+        const [jobRow] = await tx.select().from(jobs).where(eq(jobs.id, params.jobId)).limit(1).for('update');
+        if (!jobRow) throw new Error(`Job not found: ${params.jobId}`);
+        if (jobRow.version !== decision.expectedVersion && !isJobTerminal(jobRow.status)) {
+            return {
+                kind: 'stale'
+            };
+        }
+        const listenerRows = await tx.update(jobs).set({
+            listenerStatus: 'resolved',
+            resolutionReason: params.reason,
+            updatedAt: new Date()
+        }).where(and(eq(jobs.id, params.jobId), notInArray(jobs.listenerStatus, [
+            'resolved'
+        ]))).returning({
+            id: jobs.id
+        });
+        const updated = await updateJobStatusAtVersion(tx, {
+            jobId: params.jobId,
+            status: decision.status,
+            expectedVersion: decision.expectedVersion,
+            statusReason: decision.statusReason,
+            evaluationTrace: decision.trace
+        });
+        const job = updated?.job ?? toJob(jobRow);
+        const resolvedStatus = job.status === 'succeeded' ? 'succeeded' : 'failed';
+        return {
+            kind: 'applied',
+            status: resolvedStatus,
+            jobVersion: job.version,
+            changed: listenerRows.length > 0 || updated?.changed === true
+        };
+    });
+}
+export async function settleListenerJobExecution(params) {
+    const changed = await db().transaction(async (tx)=>{
+        const [execution] = await tx.update(jobExecutions).set({
+            status: params.status,
+            statusReason: params.status === 'failed' ? 'step_failed' : 'run_cancelled',
+            version: sql`${jobExecutions.version} + 1`,
+            updatedAt: new Date(),
+            finishedAt: sql`now()`
+        }).where(and(eq(jobExecutions.id, params.jobExecutionId), notInArray(jobExecutions.status, TERMINAL_EXECUTION_STATUSES))).returning();
+        if (!execution) return false;
+        await bulkUpdateStepStatuses({
+            jobExecutionId: params.jobExecutionId,
+            status: params.status
+        }, tx);
+        return true;
+    });
+    if (changed) {
+        recordWorkflowJobExecutionStatusChanged(params.status);
+    }
+}
+export async function countActiveListeners() {
+    const [row] = await db().select({
+        value: count()
+    }).from(jobs).where(eq(jobs.listenerStatus, 'listening'));
+    return row?.value ?? 0;
+}
+async function findExistingExecution(params, tx) {
+    const [existing] = await tx.select().from(jobExecutions).where(and(eq(jobExecutions.jobId, params.jobId), eq(jobExecutions.sequence, params.expectedSequence))).limit(1);
+    if (!existing) return undefined;
+    return drainExecutionResult(existing);
+}
+async function hasPendingResolveEvent(jobId, tx) {
+    const [resolveEvent] = await tx.select({
+        id: jobListenerEvents.id
+    }).from(jobListenerEvents).where(and(eq(jobListenerEvents.jobId, jobId), eq(jobListenerEvents.disposition, 'resolve'), isNull(jobListenerEvents.consumedByExecutionId))).orderBy(asc(jobListenerEvents.receivedAt), asc(jobListenerEvents.id)).limit(1).for('update');
+    return resolveEvent !== undefined;
+}
+async function lockBufferedFireEvents(params, tx) {
+    const bufferedQuery = tx.select().from(jobListenerEvents).where(and(eq(jobListenerEvents.jobId, params.jobId), eq(jobListenerEvents.disposition, 'fire'), isNull(jobListenerEvents.consumedByExecutionId))).orderBy(asc(jobListenerEvents.receivedAt), asc(jobListenerEvents.id));
+    return await (params.maxSize === undefined ? bufferedQuery : bufferedQuery.limit(params.maxSize)).for('update');
+}
+function listenerTriggerEvents(bufferedEvents) {
+    return bufferedEvents.map((event)=>({
+            source: event.source,
+            event: event.event,
+            delivery_id: event.deliveryId,
+            received_at: event.receivedAt.toISOString(),
+            data: event.payload
+        }));
+}
+async function persistMaterializedListenerExecution(tx, params) {
+    const [execution] = await tx.insert(jobExecutions).values({
+        jobId: params.jobId,
+        sequence: params.sequence,
+        name: params.materialized.name,
+        runner: params.materialized.runner.length === 0 ? null : [
+            ...params.materialized.runner
+        ],
+        status: params.materialized.status,
+        statusReason: params.materialized.statusReason,
+        triggerEvents: [
+            ...params.materialized.triggerEvents
+        ],
+        evaluationTrace: params.materialized.evaluationTrace,
+        ...params.materialized.status === 'failed' ? {
+            finishedAt: sql`now()`
+        } : {}
+    }).returning();
+    if (!execution) throw new Error('Insert returned no rows');
+    await tx.update(jobListenerEvents).set({
+        consumedByExecutionId: execution.id
+    }).where(inArray(jobListenerEvents.id, [
+        ...params.bufferedEventIds
+    ]));
+    if (params.materialized.status === 'pending' && params.materialized.steps.length > 0) {
+        await tx.insert(steps).values(params.materialized.steps.map((step)=>({
+                jobExecutionId: execution.id,
+                key: step.key,
+                name: step.name,
+                sourceLocation: step.sourceLocation,
+                status: step.status,
+                type: step.type,
+                config: step.config,
+                configPlan: step.configPlan ?? null,
+                authoredConfig: step.authoredConfig,
+                condition: step.condition ?? null,
+                position: step.position
+            })));
+    }
+    return execution;
+}
+function drainExecutionResult(execution) {
+    return {
+        kind: 'execution',
+        jobExecutionId: execution.id,
+        executionVersion: execution.version,
+        sequence: execution.sequence,
+        requiredLabels: execution.runner ?? [],
+        status: execution.status
+    };
+}
+async function loadListenerMaterializationTarget(jobId, tx) {
+    const [target] = await tx.select({
+        job: jobs,
+        attempt: workflowRunAttempts,
+        run: workflowRuns
+    }).from(jobs).innerJoin(workflowRunAttempts, eq(jobs.workflowRunAttemptId, workflowRunAttempts.id)).innerJoin(workflowRuns, eq(workflowRunAttempts.workflowRunId, workflowRuns.id)).where(eq(jobs.id, jobId)).limit(1).for('update');
+    if (!target) throw new Error(`Job not found: ${jobId}`);
+    const priorExecutions = await tx.select().from(jobExecutions).where(eq(jobExecutions.jobId, jobId)).orderBy(asc(jobExecutions.sequence), asc(jobExecutions.id));
+    return {
+        ...target,
+        priorExecutions: priorExecutions.map(toJobExecution)
+    };
+}
+
+//# sourceMappingURL=job-listeners.js.map