@shipfox/api-workflows 2.0.0

package/dist/temporal/activities/orchestration-activities.js

@@ -0,0 +1,188 @@
+import { cancelRunnerJobs, enqueueJobExecution, releaseJobExecution } from '@shipfox/api-runners';
+import { ApplicationFailure } from '@temporalio/common';
+import { defaultJobConditionTrace } from '#core/condition-trace.js';
+import { JobNotFoundError } from '#core/errors.js';
+import { activateJobListener, bulkUpdateStepStatuses, drainListenerEventsIntoExecution, evaluateJobActivations, failJobExecutionAsTimedOut, failWorkflowRunAsTimedOut, getJobExecutionsByWorkflowRunAttemptId, getJobsByWorkflowRunAttemptId, getWorkflowRunAttemptById, getWorkflowRunByAttemptId, peekListenerBuffer, resolveJobExecutionAfterLeaseExpiry, resolveJobListener, resolveJobStatusFromJobExecutions, settleListenerJobExecution, updateJobExecutionStatus, updateJobStatus, updateWorkflowRunStatus } from '#db/index.js';
+import { recordWorkflowListenerExecution } from '#metrics/instance.js';
+export async function loadRunAttemptDag(runAttemptId) {
+    const run = await getWorkflowRunByAttemptId(runAttemptId);
+    if (!run) throw new Error(`Run not found for attempt: ${runAttemptId}`);
+    const attempt = await getWorkflowRunAttemptById(runAttemptId);
+    if (!attempt) throw new Error(`Run attempt not found: ${runAttemptId}`);
+    const jobs = await getJobsByWorkflowRunAttemptId(runAttemptId);
+    const jobExecutions = await getJobExecutionsByWorkflowRunAttemptId(runAttemptId);
+    const firstJobExecutions = new Map();
+    for (const jobExecution of jobExecutions){
+        if (!firstJobExecutions.has(jobExecution.jobId)) {
+            firstJobExecutions.set(jobExecution.jobId, jobExecution);
+        }
+    }
+    return {
+        workflowRunId: run.id,
+        runAttemptId,
+        workspaceId: run.workspaceId,
+        projectId: run.projectId,
+        runVersion: attempt.version,
+        runTimeoutMs: run.timeoutMs,
+        jobs: jobs.flatMap((job)=>{
+            const jobExecution = firstJobExecutions.get(job.id);
+            const modelJob = attempt.model?.jobs.find((item)=>item.key === job.key);
+            if (!jobExecution && job.mode !== 'listening') return [];
+            return [
+                {
+                    id: job.id,
+                    key: job.key,
+                    mode: job.mode,
+                    status: job.status,
+                    ...jobExecution === undefined ? {} : {
+                        jobExecutionId: jobExecution.id,
+                        executionVersion: jobExecution.version
+                    },
+                    executionTimeoutMs: job.executionTimeoutMs,
+                    listeningTimeoutMs: job.listeningTimeoutMs,
+                    maxExecutions: job.maxExecutions,
+                    onResolve: job.onResolve,
+                    batchDebounceMs: job.batchDebounceMs,
+                    batchMaxSize: job.batchMaxSize,
+                    batchMaxWaitMs: job.batchMaxWaitMs,
+                    dependencies: job.dependencies,
+                    hasActivationCondition: modelJob?.if !== undefined,
+                    runner: jobExecution?.runner ?? job.runner ?? [],
+                    version: job.version
+                }
+            ];
+        })
+    };
+}
+export async function evaluateJobActivationsActivity(params) {
+    return await evaluateJobActivations(params);
+}
+export async function setRunAttemptStatus(params) {
+    const updated = await updateWorkflowRunStatus({
+        workflowRunAttemptId: params.runAttemptId,
+        status: params.status,
+        expectedVersion: params.version
+    });
+    return {
+        newVersion: updated.version,
+        status: updated.status
+    };
+}
+export async function setJobStatus(params) {
+    const updated = await updateJobStatus({
+        jobId: params.jobId,
+        status: params.status,
+        expectedVersion: params.version,
+        statusReason: params.statusReason,
+        evaluationTrace: jobStatusEvaluationTrace(params)
+    });
+    return {
+        newVersion: updated.version,
+        status: updated.status
+    };
+}
+function jobStatusEvaluationTrace(params) {
+    if (params.evaluationTrace !== undefined) return params.evaluationTrace;
+    return params.status === 'skipped' && params.statusReason === 'default_gate_rejected' ? defaultJobConditionTrace() : undefined;
+}
+export async function setJobExecutionStatus(params) {
+    const updated = await updateJobExecutionStatus({
+        jobExecutionId: params.jobExecutionId,
+        status: params.status,
+        expectedVersion: params.version,
+        statusReason: params.statusReason
+    });
+    return {
+        newVersion: updated.version,
+        status: updated.status
+    };
+}
+export async function bulkSetStepStatuses(params) {
+    await bulkUpdateStepStatuses(params);
+}
+export async function resolveLeaseExpiredJobExecutionActivity(params) {
+    try {
+        return await resolveJobExecutionAfterLeaseExpiry(params);
+    } catch (err) {
+        if (err instanceof JobNotFoundError) {
+            throw ApplicationFailure.nonRetryable(err.message, err.name);
+        }
+        throw err;
+    }
+}
+// Best-effort lease cleanup on job finalization. Idempotent: deleting an
+// already-released (or already-reaped) lease is a no-op. The workflow wraps the
+// call so a persistent failure never blocks the DAG result.
+export async function releaseLeaseActivity(params) {
+    await releaseJobExecution({
+        jobExecutionId: params.jobExecutionId
+    });
+}
+export async function enqueueJobExecutionForRunner(params) {
+    try {
+        await enqueueJobExecution({
+            workspaceId: params.workspaceId,
+            workflowRunId: params.workflowRunId,
+            workflowRunAttemptId: params.runAttemptId,
+            jobId: params.jobId,
+            jobExecutionId: params.jobExecutionId,
+            projectId: params.projectId,
+            requiredLabels: params.requiredLabels
+        });
+    } catch (err) {
+        if (err instanceof Error && err.name === 'EmptyRequiredLabelsError') {
+            throw ApplicationFailure.nonRetryable(err.message, err.name);
+        }
+        throw err;
+    }
+}
+export async function cancelRunnerJobsActivity(params) {
+    await cancelRunnerJobs({
+        jobIds: params.jobIds
+    });
+}
+export async function failJobExecutionAsTimedOutActivity(params) {
+    const jobExecution = await failJobExecutionAsTimedOut({
+        jobExecutionId: params.jobExecutionId,
+        workflowRunAttemptId: params.runAttemptId,
+        expectedVersion: params.expectedVersion
+    });
+    return {
+        newVersion: jobExecution.version
+    };
+}
+export async function failRunAsTimedOutActivity(params) {
+    await failWorkflowRunAsTimedOut({
+        runAttemptId: params.runAttemptId
+    });
+}
+export async function resolveJobStatusFromJobExecutionsActivity(params) {
+    return await resolveJobStatusFromJobExecutions(params);
+}
+export async function activateJobListenerActivity(params) {
+    return await activateJobListener(params);
+}
+export async function drainListenerEventsActivity(params) {
+    return await drainListenerEventsIntoExecution(params);
+}
+export async function peekListenerBufferActivity(params) {
+    return await peekListenerBuffer(params);
+}
+export async function resolveJobListenerActivity(params) {
+    return await resolveJobListener(params);
+}
+export async function settleListenerJobExecutionActivity(params) {
+    await settleListenerJobExecution(params);
+}
+// The listener workflow owns every firing's terminal outcome, but a workflow
+// sandbox cannot emit metrics. This activity is the single recording point so
+// each firing is counted exactly once, including successes that settle through
+// the child's own resolution path rather than a listener DB write. The body is
+// synchronous; it returns a resolved promise because Temporal invokes activities
+// asynchronously.
+export function recordListenerFiringOutcomeActivity(params) {
+    recordWorkflowListenerExecution(params.outcome);
+    return Promise.resolve();
+}
+
+//# sourceMappingURL=orchestration-activities.js.map

package/dist/temporal/activities/orchestration-activities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/activities/orchestration-activities.ts"],"sourcesContent":["import {cancelRunnerJobs, enqueueJobExecution, releaseJobExecution} from '@shipfox/api-runners';\nimport {ApplicationFailure} from '@temporalio/common';\nimport {defaultJobConditionTrace} from '#core/condition-trace.js';\nimport type {JobStatus, JobStatusReason, ResolutionReason} from '#core/entities/job.js';\nimport type {PersistedEvaluationTraceEntry, StepStatus} from '#core/entities/step.js';\nimport type {WorkflowRunStatus} from '#core/entities/workflow-run.js';\nimport {JobNotFoundError} from '#core/errors.js';\nimport type {\n  RuntimeCompletionStatus,\n  RuntimeDagNode,\n} from '#core/workflow-scheduling/runtime-dag.js';\nimport {\n  activateJobListener,\n  bulkUpdateStepStatuses,\n  drainListenerEventsIntoExecution,\n  type EvaluateJobActivationsParams,\n  evaluateJobActivations,\n  failJobExecutionAsTimedOut,\n  failWorkflowRunAsTimedOut,\n  getJobExecutionsByWorkflowRunAttemptId,\n  getJobsByWorkflowRunAttemptId,\n  getWorkflowRunAttemptById,\n  getWorkflowRunByAttemptId,\n  type JobActivationDecision,\n  peekListenerBuffer,\n  resolveJobExecutionAfterLeaseExpiry,\n  resolveJobListener,\n  resolveJobStatusFromJobExecutions,\n  settleListenerJobExecution,\n  updateJobExecutionStatus,\n  updateJobStatus,\n  updateWorkflowRunStatus,\n} from '#db/index.js';\nimport {recordWorkflowListenerExecution} from '#metrics/instance.js';\n\nexport interface DagJob extends RuntimeDagNode {\n  id: string;\n  key: string;\n  mode: 'one_shot' | 'listening';\n  status: JobStatus;\n  jobExecutionId?: string | undefined;\n  executionVersion?: number;\n  executionTimeoutMs?: number | null | undefined;\n  listeningTimeoutMs?: number | null | undefined;\n  maxExecutions?: number | null | undefined;\n  onResolve?: 'finish' | 'cancel' | null | undefined;\n  batchDebounceMs?: number | null | undefined;\n  batchMaxSize?: number | null | undefined;\n  batchMaxWaitMs?: number | null | undefined;\n  dependencies: string[];\n  runner: string[];\n  version: number;\n}\n\nexport interface RunDag {\n  workflowRunId: string;\n  runAttemptId: string;\n  workspaceId: string;\n  projectId: string;\n  runVersion: number;\n  runTimeoutMs: number;\n  jobs: DagJob[];\n}\n\nexport async function loadRunAttemptDag(runAttemptId: string): Promise<RunDag> {\n  const run = await getWorkflowRunByAttemptId(runAttemptId);\n  if (!run) throw new Error(`Run not found for attempt: ${runAttemptId}`);\n  const attempt = await getWorkflowRunAttemptById(runAttemptId);\n  if (!attempt) throw new Error(`Run attempt not found: ${runAttemptId}`);\n\n  const jobs = await getJobsByWorkflowRunAttemptId(runAttemptId);\n  const jobExecutions = await getJobExecutionsByWorkflowRunAttemptId(runAttemptId);\n  const firstJobExecutions = new Map<string, (typeof jobExecutions)[number]>();\n  for (const jobExecution of jobExecutions) {\n    if (!firstJobExecutions.has(jobExecution.jobId)) {\n      firstJobExecutions.set(jobExecution.jobId, jobExecution);\n    }\n  }\n\n  return {\n    workflowRunId: run.id,\n    runAttemptId,\n    workspaceId: run.workspaceId,\n    projectId: run.projectId,\n    runVersion: attempt.version,\n    runTimeoutMs: run.timeoutMs,\n    jobs: jobs.flatMap((job) => {\n      const jobExecution = firstJobExecutions.get(job.id);\n      const modelJob = attempt.model?.jobs.find((item) => item.key === job.key);\n      if (!jobExecution && job.mode !== 'listening') return [];\n      return [\n        {\n          id: job.id,\n          key: job.key,\n          mode: job.mode,\n          status: job.status,\n          ...(jobExecution === undefined\n            ? {}\n            : {jobExecutionId: jobExecution.id, executionVersion: jobExecution.version}),\n          executionTimeoutMs: job.executionTimeoutMs,\n          listeningTimeoutMs: job.listeningTimeoutMs,\n          maxExecutions: job.maxExecutions,\n          onResolve: job.onResolve,\n          batchDebounceMs: job.batchDebounceMs,\n          batchMaxSize: job.batchMaxSize,\n          batchMaxWaitMs: job.batchMaxWaitMs,\n          dependencies: job.dependencies,\n          hasActivationCondition: modelJob?.if !== undefined,\n          runner: jobExecution?.runner ?? job.runner ?? [],\n          version: job.version,\n        },\n      ];\n    }),\n  };\n}\n\nexport async function evaluateJobActivationsActivity(\n  params: EvaluateJobActivationsParams,\n): Promise<JobActivationDecision[]> {\n  return await evaluateJobActivations(params);\n}\n\nexport async function setRunAttemptStatus(params: {\n  runAttemptId: string;\n  status: WorkflowRunStatus;\n  version: number;\n}): Promise<{newVersion: number; status: WorkflowRunStatus}> {\n  const updated = await updateWorkflowRunStatus({\n    workflowRunAttemptId: params.runAttemptId,\n    status: params.status,\n    expectedVersion: params.version,\n  });\n  return {newVersion: updated.version, status: updated.status};\n}\n\nexport async function setJobStatus(params: {\n  jobId: string;\n  status: JobStatus;\n  version: number;\n  statusReason?: JobStatusReason | null | undefined;\n  evaluationTrace?: readonly PersistedEvaluationTraceEntry[] | null | undefined;\n}): Promise<{newVersion: number; status: JobStatus}> {\n  const updated = await updateJobStatus({\n    jobId: params.jobId,\n    status: params.status,\n    expectedVersion: params.version,\n    statusReason: params.statusReason,\n    evaluationTrace: jobStatusEvaluationTrace(params),\n  });\n  return {newVersion: updated.version, status: updated.status};\n}\n\nfunction jobStatusEvaluationTrace(params: {\n  status: JobStatus;\n  statusReason?: JobStatusReason | null | undefined;\n  evaluationTrace?: readonly PersistedEvaluationTraceEntry[] | null | undefined;\n}): readonly PersistedEvaluationTraceEntry[] | null | undefined {\n  if (params.evaluationTrace !== undefined) return params.evaluationTrace;\n  return params.status === 'skipped' && params.statusReason === 'default_gate_rejected'\n    ? defaultJobConditionTrace()\n    : undefined;\n}\n\nexport async function setJobExecutionStatus(params: {\n  jobExecutionId: string;\n  status: Exclude<JobStatus, 'skipped'>;\n  version: number;\n  statusReason?: JobStatusReason | null | undefined;\n}): Promise<{newVersion: number; status: Exclude<JobStatus, 'skipped'>}> {\n  const updated = await updateJobExecutionStatus({\n    jobExecutionId: params.jobExecutionId,\n    status: params.status,\n    expectedVersion: params.version,\n    statusReason: params.statusReason,\n  });\n  return {newVersion: updated.version, status: updated.status};\n}\n\nexport async function bulkSetStepStatuses(params: {\n  jobExecutionId: string;\n  status: Extract<StepStatus, 'failed' | 'cancelled'>;\n}): Promise<void> {\n  await bulkUpdateStepStatuses(params);\n}\n\nexport async function resolveLeaseExpiredJobExecutionActivity(params: {\n  jobExecutionId: string;\n  expectedVersion: number;\n}): Promise<{status: RuntimeCompletionStatus; executionVersion: number}> {\n  try {\n    return await resolveJobExecutionAfterLeaseExpiry(params);\n  } catch (err) {\n    if (err instanceof JobNotFoundError) {\n      throw ApplicationFailure.nonRetryable(err.message, err.name);\n    }\n    throw err;\n  }\n}\n\n// Best-effort lease cleanup on job finalization. Idempotent: deleting an\n// already-released (or already-reaped) lease is a no-op. The workflow wraps the\n// call so a persistent failure never blocks the DAG result.\nexport async function releaseLeaseActivity(params: {jobExecutionId: string}): Promise<void> {\n  await releaseJobExecution({jobExecutionId: params.jobExecutionId});\n}\n\nexport async function enqueueJobExecutionForRunner(params: {\n  workspaceId: string;\n  workflowRunId: string;\n  jobId: string;\n  jobExecutionId: string;\n  runAttemptId: string;\n  projectId: string;\n  requiredLabels: string[];\n}): Promise<void> {\n  try {\n    await enqueueJobExecution({\n      workspaceId: params.workspaceId,\n      workflowRunId: params.workflowRunId,\n      workflowRunAttemptId: params.runAttemptId,\n      jobId: params.jobId,\n      jobExecutionId: params.jobExecutionId,\n      projectId: params.projectId,\n      requiredLabels: params.requiredLabels,\n    });\n  } catch (err) {\n    if (err instanceof Error && err.name === 'EmptyRequiredLabelsError') {\n      throw ApplicationFailure.nonRetryable(err.message, err.name);\n    }\n    throw err;\n  }\n}\n\nexport async function cancelRunnerJobsActivity(params: {jobIds: string[]}): Promise<void> {\n  await cancelRunnerJobs({jobIds: params.jobIds});\n}\n\nexport async function failJobExecutionAsTimedOutActivity(params: {\n  jobExecutionId: string;\n  runAttemptId: string;\n  expectedVersion: number;\n}): Promise<{newVersion: number}> {\n  const jobExecution = await failJobExecutionAsTimedOut({\n    jobExecutionId: params.jobExecutionId,\n    workflowRunAttemptId: params.runAttemptId,\n    expectedVersion: params.expectedVersion,\n  });\n  return {newVersion: jobExecution.version};\n}\n\nexport async function failRunAsTimedOutActivity(params: {runAttemptId: string}): Promise<void> {\n  await failWorkflowRunAsTimedOut({runAttemptId: params.runAttemptId});\n}\n\nexport async function resolveJobStatusFromJobExecutionsActivity(params: {\n  jobId: string;\n}): Promise<{status: RuntimeCompletionStatus; jobVersion: number}> {\n  return await resolveJobStatusFromJobExecutions(params);\n}\n\nexport async function activateJobListenerActivity(params: {\n  jobId: string;\n  expectedVersion: number;\n}) {\n  return await activateJobListener(params);\n}\n\nexport async function drainListenerEventsActivity(params: {\n  jobId: string;\n  expectedSequence: number;\n  maxSize?: number | undefined;\n}) {\n  return await drainListenerEventsIntoExecution(params);\n}\n\nexport async function peekListenerBufferActivity(params: {jobId: string}) {\n  return await peekListenerBuffer(params);\n}\n\nexport async function resolveJobListenerActivity(params: {\n  jobId: string;\n  reason: ResolutionReason;\n}) {\n  return await resolveJobListener(params);\n}\n\nexport async function settleListenerJobExecutionActivity(params: {\n  jobExecutionId: string;\n  status: 'failed' | 'cancelled';\n}) {\n  await settleListenerJobExecution(params);\n}\n\n// The listener workflow owns every firing's terminal outcome, but a workflow\n// sandbox cannot emit metrics. This activity is the single recording point so\n// each firing is counted exactly once, including successes that settle through\n// the child's own resolution path rather than a listener DB write. The body is\n// synchronous; it returns a resolved promise because Temporal invokes activities\n// asynchronously.\nexport function recordListenerFiringOutcomeActivity(params: {\n  outcome: 'succeeded' | 'failed' | 'cancelled';\n}): Promise<void> {\n  recordWorkflowListenerExecution(params.outcome);\n  return Promise.resolve();\n}\n"],"names":["cancelRunnerJobs","enqueueJobExecution","releaseJobExecution","ApplicationFailure","defaultJobConditionTrace","JobNotFoundError","activateJobListener","bulkUpdateStepStatuses","drainListenerEventsIntoExecution","evaluateJobActivations","failJobExecutionAsTimedOut","failWorkflowRunAsTimedOut","getJobExecutionsByWorkflowRunAttemptId","getJobsByWorkflowRunAttemptId","getWorkflowRunAttemptById","getWorkflowRunByAttemptId","peekListenerBuffer","resolveJobExecutionAfterLeaseExpiry","resolveJobListener","resolveJobStatusFromJobExecutions","settleListenerJobExecution","updateJobExecutionStatus","updateJobStatus","updateWorkflowRunStatus","recordWorkflowListenerExecution","loadRunAttemptDag","runAttemptId","run","Error","attempt","jobs","jobExecutions","firstJobExecutions","Map","jobExecution","has","jobId","set","workflowRunId","id","workspaceId","projectId","runVersion","version","runTimeoutMs","timeoutMs","flatMap","job","get","modelJob","model","find","item","key","mode","status","undefined","jobExecutionId","executionVersion","executionTimeoutMs","listeningTimeoutMs","maxExecutions","onResolve","batchDebounceMs","batchMaxSize","batchMaxWaitMs","dependencies","hasActivationCondition","if","runner","evaluateJobActivationsActivity","params","setRunAttemptStatus","updated","workflowRunAttemptId","expectedVersion","newVersion","setJobStatus","statusReason","evaluationTrace","jobStatusEvaluationTrace","setJobExecutionStatus","bulkSetStepStatuses","resolveLeaseExpiredJobExecutionActivity","err","nonRetryable","message","name","releaseLeaseActivity","enqueueJobExecutionForRunner","requiredLabels","cancelRunnerJobsActivity","jobIds","failJobExecutionAsTimedOutActivity","failRunAsTimedOutActivity","resolveJobStatusFromJobExecutionsActivity","activateJobListenerActivity","drainListenerEventsActivity","peekListenerBufferActivity","resolveJobListenerActivity","settleListenerJobExecutionActivity","recordListenerFiringOutcomeActivity","outcome","Promise","resolve"],"mappings":"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"}

package/dist/temporal/constants.d.ts

@@ -0,0 +1,7 @@
+export declare const WORKFLOWS_TASK_QUEUE = "workflows-orchestrator";
+export declare const RUN_CANCEL_SIGNAL = "run-cancel";
+export declare const JOB_FINISHED_SIGNAL = "job-finished";
+export declare const JOB_LEASE_EXPIRED_SIGNAL = "job-lease-expired";
+export declare const LISTENER_EVENTS_AVAILABLE_SIGNAL = "events-available";
+export declare const LISTENER_RESOLVE_SIGNAL = "resolve";
+//# sourceMappingURL=constants.d.ts.map

package/dist/temporal/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/temporal/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,2BAA2B,CAAC;AAC7D,eAAO,MAAM,iBAAiB,eAAe,CAAC;AAC9C,eAAO,MAAM,mBAAmB,iBAAiB,CAAC;AAClD,eAAO,MAAM,wBAAwB,sBAAsB,CAAC;AAC5D,eAAO,MAAM,gCAAgC,qBAAqB,CAAC;AACnE,eAAO,MAAM,uBAAuB,YAAY,CAAC"}

package/dist/temporal/constants.js

@@ -0,0 +1,8 @@
+export const WORKFLOWS_TASK_QUEUE = 'workflows-orchestrator';
+export const RUN_CANCEL_SIGNAL = 'run-cancel';
+export const JOB_FINISHED_SIGNAL = 'job-finished';
+export const JOB_LEASE_EXPIRED_SIGNAL = 'job-lease-expired';
+export const LISTENER_EVENTS_AVAILABLE_SIGNAL = 'events-available';
+export const LISTENER_RESOLVE_SIGNAL = 'resolve';
+
+//# sourceMappingURL=constants.js.map

package/dist/temporal/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/constants.ts"],"sourcesContent":["export const WORKFLOWS_TASK_QUEUE = 'workflows-orchestrator';\nexport const RUN_CANCEL_SIGNAL = 'run-cancel';\nexport const JOB_FINISHED_SIGNAL = 'job-finished';\nexport const JOB_LEASE_EXPIRED_SIGNAL = 'job-lease-expired';\nexport const LISTENER_EVENTS_AVAILABLE_SIGNAL = 'events-available';\nexport const LISTENER_RESOLVE_SIGNAL = 'resolve';\n"],"names":["WORKFLOWS_TASK_QUEUE","RUN_CANCEL_SIGNAL","JOB_FINISHED_SIGNAL","JOB_LEASE_EXPIRED_SIGNAL","LISTENER_EVENTS_AVAILABLE_SIGNAL","LISTENER_RESOLVE_SIGNAL"],"mappings":"AAAA,OAAO,MAAMA,uBAAuB,yBAAyB;AAC7D,OAAO,MAAMC,oBAAoB,aAAa;AAC9C,OAAO,MAAMC,sBAAsB,eAAe;AAClD,OAAO,MAAMC,2BAA2B,oBAAoB;AAC5D,OAAO,MAAMC,mCAAmC,mBAAmB;AACnE,OAAO,MAAMC,0BAA0B,UAAU"}

package/dist/temporal/index.d.ts

@@ -0,0 +1,3 @@
+export { createOrchestrationActivities } from './activities/index.js';
+export { JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL, WORKFLOWS_TASK_QUEUE, } from './constants.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/temporal/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,6BAA6B,EAAC,MAAM,uBAAuB,CAAC;AACpE,OAAO,EACL,mBAAmB,EACnB,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,gBAAgB,CAAC"}

package/dist/temporal/index.js

@@ -0,0 +1,4 @@
+export { createOrchestrationActivities } from './activities/index.js';
+export { JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL, WORKFLOWS_TASK_QUEUE } from './constants.js';
+
+//# sourceMappingURL=index.js.map

package/dist/temporal/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/index.ts"],"sourcesContent":["export {createOrchestrationActivities} from './activities/index.js';\nexport {\n  JOB_FINISHED_SIGNAL,\n  JOB_LEASE_EXPIRED_SIGNAL,\n  WORKFLOWS_TASK_QUEUE,\n} from './constants.js';\n"],"names":["createOrchestrationActivities","JOB_FINISHED_SIGNAL","JOB_LEASE_EXPIRED_SIGNAL","WORKFLOWS_TASK_QUEUE"],"mappings":"AAAA,SAAQA,6BAA6B,QAAO,wBAAwB;AACpE,SACEC,mBAAmB,EACnBC,wBAAwB,EACxBC,oBAAoB,QACf,iBAAiB"}

package/dist/temporal/workflow-not-found.d.ts

@@ -0,0 +1,2 @@
+export declare function isWorkflowNotFound(err: unknown): boolean;
+//# sourceMappingURL=workflow-not-found.d.ts.map

package/dist/temporal/workflow-not-found.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-not-found.d.ts","sourceRoot":"","sources":["../../src/temporal/workflow-not-found.ts"],"names":[],"mappings":"AAMA,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO,CAExD"}

package/dist/temporal/workflow-not-found.js

@@ -0,0 +1,10 @@
+// A signal to a workflow that has already terminated (it finished or hit the
+// timeout backstop first) throws WorkflowNotFoundError. Match on the error name
+// rather than `instanceof` so the check holds regardless of which @temporalio
+// package instance constructed the error.
+const WORKFLOW_NOT_FOUND = 'WorkflowNotFoundError';
+export function isWorkflowNotFound(err) {
+    return err instanceof Error && err.name === WORKFLOW_NOT_FOUND;
+}
+
+//# sourceMappingURL=workflow-not-found.js.map

package/dist/temporal/workflow-not-found.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/temporal/workflow-not-found.ts"],"sourcesContent":["// A signal to a workflow that has already terminated (it finished or hit the\n// timeout backstop first) throws WorkflowNotFoundError. Match on the error name\n// rather than `instanceof` so the check holds regardless of which @temporalio\n// package instance constructed the error.\nconst WORKFLOW_NOT_FOUND = 'WorkflowNotFoundError';\n\nexport function isWorkflowNotFound(err: unknown): boolean {\n  return err instanceof Error && err.name === WORKFLOW_NOT_FOUND;\n}\n"],"names":["WORKFLOW_NOT_FOUND","isWorkflowNotFound","err","Error","name"],"mappings":"AAAA,6EAA6E;AAC7E,gFAAgF;AAChF,8EAA8E;AAC9E,0CAA0C;AAC1C,MAAMA,qBAAqB;AAE3B,OAAO,SAASC,mBAAmBC,GAAY;IAC7C,OAAOA,eAAeC,SAASD,IAAIE,IAAI,KAAKJ;AAC9C"}

package/dist/temporal/workflows/deadline.d.ts

@@ -0,0 +1,3 @@
+export declare function deadlineReached(deadline: number | undefined): boolean;
+export declare function remainingMs(deadline: number | undefined): number | undefined;
+//# sourceMappingURL=deadline.d.ts.map

package/dist/temporal/workflows/deadline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deadline.d.ts","sourceRoot":"","sources":["../../../src/temporal/workflows/deadline.ts"],"names":[],"mappings":"AAAA,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAErE;AAED,wBAAgB,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAE5E"}

package/dist/temporal/workflows/deadline.js

@@ -0,0 +1,8 @@
+export function deadlineReached(deadline) {
+    return deadline !== undefined && Date.now() >= deadline;
+}
+export function remainingMs(deadline) {
+    return deadline === undefined ? undefined : Math.max(0, deadline - Date.now());
+}
+
+//# sourceMappingURL=deadline.js.map

package/dist/temporal/workflows/deadline.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/workflows/deadline.ts"],"sourcesContent":["export function deadlineReached(deadline: number | undefined): boolean {\n  return deadline !== undefined && Date.now() >= deadline;\n}\n\nexport function remainingMs(deadline: number | undefined): number | undefined {\n  return deadline === undefined ? undefined : Math.max(0, deadline - Date.now());\n}\n"],"names":["deadlineReached","deadline","undefined","Date","now","remainingMs","Math","max"],"mappings":"AAAA,OAAO,SAASA,gBAAgBC,QAA4B;IAC1D,OAAOA,aAAaC,aAAaC,KAAKC,GAAG,MAAMH;AACjD;AAEA,OAAO,SAASI,YAAYJ,QAA4B;IACtD,OAAOA,aAAaC,YAAYA,YAAYI,KAAKC,GAAG,CAAC,GAAGN,WAAWE,KAAKC,GAAG;AAC7E"}

package/dist/temporal/workflows/index.d.ts

@@ -0,0 +1,4 @@
+export { jobExecutionOrchestration, jobFinishedSignal, jobLeaseExpiredSignal, } from './job-execution-orchestration.js';
+export { jobListenerOrchestration, listenerEventsAvailableSignal, listenerResolveSignal, } from './job-listener-orchestration.js';
+export { runOrchestration } from './run-orchestration.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/temporal/workflows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/temporal/workflows/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,qBAAqB,GACtB,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,wBAAwB,EACxB,6BAA6B,EAC7B,qBAAqB,GACtB,MAAM,iCAAiC,CAAC;AACzC,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC"}

package/dist/temporal/workflows/index.js

@@ -0,0 +1,5 @@
+export { jobExecutionOrchestration, jobFinishedSignal, jobLeaseExpiredSignal } from './job-execution-orchestration.js';
+export { jobListenerOrchestration, listenerEventsAvailableSignal, listenerResolveSignal } from './job-listener-orchestration.js';
+export { runOrchestration } from './run-orchestration.js';
+
+//# sourceMappingURL=index.js.map

package/dist/temporal/workflows/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/workflows/index.ts"],"sourcesContent":["export {\n  jobExecutionOrchestration,\n  jobFinishedSignal,\n  jobLeaseExpiredSignal,\n} from './job-execution-orchestration.js';\nexport {\n  jobListenerOrchestration,\n  listenerEventsAvailableSignal,\n  listenerResolveSignal,\n} from './job-listener-orchestration.js';\nexport {runOrchestration} from './run-orchestration.js';\n"],"names":["jobExecutionOrchestration","jobFinishedSignal","jobLeaseExpiredSignal","jobListenerOrchestration","listenerEventsAvailableSignal","listenerResolveSignal","runOrchestration"],"mappings":"AAAA,SACEA,yBAAyB,EACzBC,iBAAiB,EACjBC,qBAAqB,QAChB,mCAAmC;AAC1C,SACEC,wBAAwB,EACxBC,6BAA6B,EAC7BC,qBAAqB,QAChB,kCAAkC;AACzC,SAAQC,gBAAgB,QAAO,yBAAyB"}

package/dist/temporal/workflows/job-execution-orchestration.d.ts

@@ -0,0 +1,27 @@
+import type { RuntimeCompletionStatus } from '#core/workflow-scheduling/runtime-dag.js';
+export declare const jobFinishedSignal: import("@temporalio/common").SignalDefinition<[{
+    status: RuntimeCompletionStatus;
+    jobExecutionId?: string | undefined;
+}], string>;
+export declare const jobLeaseExpiredSignal: import("@temporalio/common").SignalDefinition<[{
+    jobExecutionId?: string | undefined;
+}], string>;
+export interface JobExecutionOrchestrationInput {
+    workspaceId: string;
+    workflowRunId: string;
+    runAttemptId: string;
+    jobId: string;
+    jobExecutionId: string;
+    projectId: string;
+    jobVersion: number;
+    executionVersion: number;
+    executionTimeoutMs?: number | null | undefined;
+    resolveJobStatus?: boolean | undefined;
+    requiredLabels: string[];
+}
+export interface JobExecutionOrchestrationResult {
+    status: RuntimeCompletionStatus;
+    jobVersion: number;
+}
+export declare function jobExecutionOrchestration(input: JobExecutionOrchestrationInput): Promise<JobExecutionOrchestrationResult>;
+//# sourceMappingURL=job-execution-orchestration.d.ts.map

package/dist/temporal/workflows/job-execution-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"job-execution-orchestration.d.ts","sourceRoot":"","sources":["../../../src/temporal/workflows/job-execution-orchestration.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,0CAA0C,CAAC;AAoDtF,eAAO,MAAM,iBAAiB;YACL,uBAAuB;qBAAmB,MAAM,GAAG,SAAS;WAElF,CAAC;AACJ,eAAO,MAAM,qBAAqB;qBACA,MAAM,GAAG,SAAS;WAA6B,CAAC;AAElF,MAAM,WAAW,8BAA8B;IAC7C,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,gBAAgB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACvC,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B;AAED,MAAM,WAAW,+BAA+B;IAC9C,MAAM,EAAE,uBAAuB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAyMD,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,8BAA8B,GACpC,OAAO,CAAC,+BAA+B,CAAC,CA0B1C"}

package/dist/temporal/workflows/job-execution-orchestration.js

@@ -0,0 +1,265 @@
+import { ApplicationFailure } from '@temporalio/common';
+import { condition, defineSignal, log, proxyActivities, setHandler } from '@temporalio/workflow';
+import { hasNoRequiredRunnerLabels, jobExecutionStartOutcome, resolveJobExecutionOutcomeSignal } from '#core/job-execution-outcome.js';
+import { JOB_FINISHED_SIGNAL, JOB_LEASE_EXPIRED_SIGNAL } from '../constants.js';
+/**
+ * Two signals, one precedence ladder, then best-effort lease release:
+ *
+ *   job-finished (recordStepResult exhausted the steps) ─┐
+ *   job-lease-expired (runner heartbeat went stale) ─────┤
+ *                                                        ▼
+ *   condition(finished ∥ leaseExpired, executionTimeout)
+ *     ├─ finished      → setJobExecutionStatus(status) + resolve job status     ─┐
+ *     ├─ leaseExpired  → resolveLeaseExpiredJobExecutionActivity                 ─┤→ releaseLease
+ *     └─ neither (6h)  → failJobExecutionAsTimedOutActivity + sweep steps (NO release; the
+ *                        TIMED_OUT event drives cooperative cancel, the detector reaps)
+ *
+ * Both signals can be delivered before condition() resumes (independent outboxes,
+ * no ordering), so finished is evaluated FIRST: a genuinely-finished job is never
+ * flipped to failed by a late lease-expiry. releaseLease is best-effort — a runners
+ * DB outage must never block the child workflow from returning the job outcome to
+ * run-orchestration; a leftover lease row is reaped by the stuck detector.
+ */ const { setJobStatus, setJobExecutionStatus, enqueueJobExecutionForRunner, bulkSetStepStatuses, failJobExecutionAsTimedOutActivity, resolveLeaseExpiredJobExecutionActivity } = proxyActivities({
+    startToCloseTimeout: '30s'
+});
+const { resolveJobStatusFromJobExecutionsActivity } = proxyActivities({
+    startToCloseTimeout: '30s',
+    retry: {
+        maximumAttempts: 5
+    }
+});
+// Lease cleanup gets a bounded retry policy of its own: after a few attempts the
+// workflow stops waiting on it (see releaseLeaseBestEffort) rather than blocking
+// the DAG on runners-side availability.
+const { releaseLeaseActivity } = proxyActivities({
+    startToCloseTimeout: '30s',
+    retry: {
+        maximumAttempts: 5
+    }
+});
+const DEFAULT_EXECUTION_MAX_DURATION_MS = 6 * 60 * 60 * 1000;
+export const jobFinishedSignal = defineSignal(JOB_FINISHED_SIGNAL);
+export const jobLeaseExpiredSignal = defineSignal(JOB_LEASE_EXPIRED_SIGNAL);
+async function releaseLeaseBestEffort(jobExecutionId) {
+    try {
+        await releaseLeaseActivity({
+            jobExecutionId
+        });
+    } catch (err) {
+        log.warn('lease release failed; stuck detector will reap the row', {
+            jobExecutionId,
+            error: String(err)
+        });
+    }
+}
+async function resolveJobStatusOrFailClosed(input) {
+    try {
+        return await resolveJobStatusFromJobExecutionsActivity({
+            jobId: input.jobId
+        });
+    } catch (err) {
+        log.error('job status resolution failed; failing job closed', {
+            jobId: input.jobId,
+            jobExecutionId: input.jobExecutionId,
+            error: String(err)
+        });
+        const { newVersion } = await setJobStatus({
+            jobId: input.jobId,
+            status: 'failed',
+            version: input.jobVersion,
+            statusReason: 'step_failed'
+        });
+        return {
+            status: 'failed',
+            jobVersion: newVersion
+        };
+    }
+}
+async function markJobExecutionRunningAndEnqueue(input) {
+    if (hasNoRequiredRunnerLabels(input.requiredLabels)) {
+        throw ApplicationFailure.nonRetryable(`Job ${input.jobId} has no required runner labels`, 'EmptyRequiredLabelsError');
+    }
+    const { newVersion: runningVersion, status } = await setJobExecutionStatus({
+        jobExecutionId: input.jobExecutionId,
+        status: 'running',
+        version: input.executionVersion
+    });
+    const start = jobExecutionStartOutcome({
+        newVersion: runningVersion,
+        status
+    });
+    if (start.kind === 'terminal') return start;
+    await enqueueJobExecutionForRunner({
+        workspaceId: input.workspaceId,
+        workflowRunId: input.workflowRunId,
+        runAttemptId: input.runAttemptId,
+        jobId: input.jobId,
+        jobExecutionId: input.jobExecutionId,
+        projectId: input.projectId,
+        requiredLabels: input.requiredLabels
+    });
+    return {
+        kind: 'running',
+        runningVersion
+    };
+}
+// Both signals can arrive before condition() resumes (independent outboxes, no
+// ordering), so callers must evaluate `finished` before `leaseExpired`.
+async function awaitJobOutcome(jobExecutionId, timeoutMs) {
+    let finished;
+    let leaseExpired = false;
+    setHandler(jobFinishedSignal, (payload)=>{
+        if (payload.jobExecutionId !== undefined && payload.jobExecutionId !== jobExecutionId) return;
+        finished ??= payload;
+    });
+    setHandler(jobLeaseExpiredSignal, (payload = {})=>{
+        if (payload.jobExecutionId !== undefined && payload.jobExecutionId !== jobExecutionId) return;
+        leaseExpired = true;
+    });
+    await condition(()=>finished !== undefined || leaseExpired, timeoutMs);
+    return {
+        finished,
+        leaseExpired
+    };
+}
+async function resolveFinishedJobExecution({ input, runningVersion, status }) {
+    await setJobExecutionStatus({
+        jobExecutionId: input.jobExecutionId,
+        status: jobExecutionStatusForRuntimeStatus(status),
+        version: runningVersion,
+        statusReason: status === 'failed' ? 'step_failed' : null
+    });
+    if (input.resolveJobStatus === false) {
+        log.info('job execution terminated', {
+            jobId: input.jobId,
+            jobExecutionId: input.jobExecutionId,
+            terminationReason: 'finished',
+            status
+        });
+        await releaseLeaseBestEffort(input.jobExecutionId);
+        return {
+            status,
+            jobVersion: input.jobVersion
+        };
+    }
+    const resolved = await resolveJobStatusOrFailClosed(input);
+    log.info('job execution terminated', {
+        jobId: input.jobId,
+        jobExecutionId: input.jobExecutionId,
+        terminationReason: 'finished',
+        status: resolved.status
+    });
+    await releaseLeaseBestEffort(input.jobExecutionId);
+    return resolved;
+}
+function jobExecutionStatusForRuntimeStatus(status) {
+    if (status === 'succeeded' || status === 'failed' || status === 'cancelled') return status;
+    throw ApplicationFailure.nonRetryable(`Job execution cannot be marked ${status}`, 'InvalidJobExecutionStatusError');
+}
+async function resolveLeaseExpiredJobExecution({ input, runningVersion }) {
+    const leaseExpired = await resolveLeaseExpiredJobExecutionActivity({
+        jobExecutionId: input.jobExecutionId,
+        expectedVersion: runningVersion
+    });
+    if (input.resolveJobStatus === false) {
+        log.info('job execution terminated', {
+            jobId: input.jobId,
+            jobExecutionId: input.jobExecutionId,
+            terminationReason: 'lease_expired',
+            status: leaseExpired.status
+        });
+        await releaseLeaseBestEffort(input.jobExecutionId);
+        return {
+            status: leaseExpired.status,
+            jobVersion: input.jobVersion
+        };
+    }
+    const { status, jobVersion } = await resolveJobStatusOrFailClosed(input);
+    log.info('job execution terminated', {
+        jobId: input.jobId,
+        jobExecutionId: input.jobExecutionId,
+        terminationReason: 'lease_expired',
+        status
+    });
+    await releaseLeaseBestEffort(input.jobExecutionId);
+    return {
+        status,
+        jobVersion
+    };
+}
+// Timeout backstop. The activity atomically fails the execution, marks
+// `timed_out_at`, and enqueues WORKFLOWS_JOB_EXECUTION_TIMED_OUT; the runners subscriber
+// then asks the runner to cancel. The lease is intentionally NOT released here.
+async function resolveTimedOutJobExecution({ input, runningVersion }) {
+    await failJobExecutionAsTimedOutActivity({
+        jobExecutionId: input.jobExecutionId,
+        runAttemptId: input.runAttemptId,
+        expectedVersion: runningVersion
+    });
+    await bulkSetStepStatuses({
+        jobExecutionId: input.jobExecutionId,
+        status: 'failed'
+    });
+    if (input.resolveJobStatus === false) {
+        log.info('job execution terminated', {
+            jobId: input.jobId,
+            jobExecutionId: input.jobExecutionId,
+            terminationReason: 'max_duration',
+            status: 'failed'
+        });
+        return {
+            status: 'failed',
+            jobVersion: input.jobVersion
+        };
+    }
+    const { jobVersion } = await resolveJobStatusOrFailClosed(input);
+    log.info('job execution terminated', {
+        jobId: input.jobId,
+        jobExecutionId: input.jobExecutionId,
+        terminationReason: 'max_duration',
+        status: 'failed'
+    });
+    return {
+        status: 'failed',
+        jobVersion
+    };
+}
+export async function jobExecutionOrchestration(input) {
+    const running = await markJobExecutionRunningAndEnqueue(input);
+    if (running.kind === 'terminal') {
+        if (input.resolveJobStatus === false) {
+            return {
+                status: running.result.status,
+                jobVersion: input.jobVersion
+            };
+        }
+        return running.result;
+    }
+    const { runningVersion } = running;
+    const timeoutMs = input.executionTimeoutMs ?? DEFAULT_EXECUTION_MAX_DURATION_MS;
+    const signals = await awaitJobOutcome(input.jobExecutionId, timeoutMs);
+    // Precedence ladder: a genuinely-finished job is never flipped to failed by a
+    // late lease-expiry, so `finished` wins over `leaseExpired`.
+    const resolution = resolveJobExecutionOutcomeSignal(signals);
+    if (resolution === 'finished') {
+        const { finished } = signals;
+        if (finished === undefined) throw new Error('Missing finished signal for finished resolution');
+        return resolveFinishedJobExecution({
+            input,
+            runningVersion,
+            status: finished.status
+        });
+    }
+    if (resolution === 'lease-expired') {
+        return resolveLeaseExpiredJobExecution({
+            input,
+            runningVersion
+        });
+    }
+    return resolveTimedOutJobExecution({
+        input,
+        runningVersion
+    });
+}
+
+//# sourceMappingURL=job-execution-orchestration.js.map