@shipfox/api-workflows 2.0.0

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

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

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

@@ -0,0 +1,40 @@
+import type { ResolutionReason } from '#core/entities/job.js';
+import type { RuntimeCompletionStatus } from '#core/workflow-scheduling/runtime-dag.js';
+export declare const listenerEventsAvailableSignal: import("@temporalio/workflow").SignalDefinition<[], string>;
+export declare const listenerResolveSignal: import("@temporalio/workflow").SignalDefinition<[], string>;
+export interface JobListenerOrchestrationInput {
+    workspaceId: string;
+    workflowRunId: string;
+    projectId: string;
+    runAttemptId: string;
+    jobId: string;
+    jobVersion: number;
+    requiredLabels: string[];
+    executionTimeoutMs?: number | null | undefined;
+    listeningTimeoutMs?: number | null | undefined;
+    maxExecutions?: number | null | undefined;
+    onResolve?: 'finish' | 'cancel' | null | undefined;
+    batchDebounceMs?: number | null | undefined;
+    batchMaxSize?: number | null | undefined;
+    batchMaxWaitMs?: number | null | undefined;
+    continuation?: ListenerContinuationState | undefined;
+}
+export interface JobListenerOrchestrationResult {
+    status: RuntimeCompletionStatus;
+    jobVersion: number;
+}
+type ResolutionLatch = Exclude<ResolutionReason, 'cancelled'> | undefined;
+export interface ListenerContinuationState {
+    nextSequence: number;
+    latchedReason?: ResolutionLatch;
+    listenerDeadline?: number | undefined;
+}
+export declare const LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT = 500;
+export declare function jobListenerOrchestration(input: JobListenerOrchestrationInput): Promise<JobListenerOrchestrationResult>;
+export declare function shouldContinueListenerAsNew(params: {
+    firingsInCurrentRun: number;
+    continueAsNewSuggested: boolean;
+}): boolean;
+export declare function listenerContinuationInput(input: JobListenerOrchestrationInput, continuation: ListenerContinuationState): JobListenerOrchestrationInput;
+export {};
+//# sourceMappingURL=job-listener-orchestration.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"job-listener-orchestration.d.ts","sourceRoot":"","sources":["../../../src/temporal/workflows/job-listener-orchestration.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAC,uBAAuB,EAAC,MAAM,0CAA0C,CAAC;AAkBtF,eAAO,MAAM,6BAA6B,6DAAqD,CAAC;AAChG,eAAO,MAAM,qBAAqB,6DAA4C,CAAC;AAE/E,MAAM,WAAW,6BAA6B;IAC5C,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,kBAAkB,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC/C,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC1C,SAAS,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,IAAI,GAAG,SAAS,CAAC;IACnD,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC5C,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACzC,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IAC3C,YAAY,CAAC,EAAE,yBAAyB,GAAG,SAAS,CAAC;CACtD;AAED,MAAM,WAAW,8BAA8B;IAC7C,MAAM,EAAE,uBAAuB,CAAC;IAChC,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,KAAK,eAAe,GAAG,OAAO,CAAC,gBAAgB,EAAE,WAAW,CAAC,GAAG,SAAS,CAAC;AAG1E,MAAM,WAAW,yBAAyB;IACxC,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,eAAe,CAAC;IAChC,gBAAgB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC;AAED,eAAO,MAAM,qCAAqC,MAAM,CAAC;AAwBzD,wBAAsB,wBAAwB,CAC5C,KAAK,EAAE,6BAA6B,GACnC,OAAO,CAAC,8BAA8B,CAAC,CAuIzC;AAiCD,wBAAgB,2BAA2B,CAAC,MAAM,EAAE;IAClD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,sBAAsB,EAAE,OAAO,CAAC;CACjC,GAAG,OAAO,CAKV;AAED,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,6BAA6B,EACpC,YAAY,EAAE,yBAAyB,GACtC,6BAA6B,CAE/B"}

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

@@ -0,0 +1,332 @@
+import { CancellationScope, condition, continueAsNew, defineSignal, executeChild, log, ParentClosePolicy, proxyActivities, setHandler, workflowInfo } from '@temporalio/workflow';
+import { runtimeStatusForTerminalJobExecutionStatus } from '#core/job-execution-outcome.js';
+import { LISTENER_EVENTS_AVAILABLE_SIGNAL, LISTENER_RESOLVE_SIGNAL } from '../constants.js';
+import { deadlineReached, remainingMs } from './deadline.js';
+import { jobExecutionOrchestration } from './job-execution-orchestration.js';
+const { activateJobListenerActivity, drainListenerEventsActivity, peekListenerBufferActivity, resolveJobListenerActivity, settleListenerJobExecutionActivity, recordListenerFiringOutcomeActivity, cancelRunnerJobsActivity } = proxyActivities({
+    startToCloseTimeout: '30s'
+});
+export const listenerEventsAvailableSignal = defineSignal(LISTENER_EVENTS_AVAILABLE_SIGNAL);
+export const listenerResolveSignal = defineSignal(LISTENER_RESOLVE_SIGNAL);
+export const LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT = 500;
+export async function jobListenerOrchestration(input) {
+    let eventsAvailable = false;
+    let latchedReason = input.continuation?.latchedReason;
+    setHandler(listenerEventsAvailableSignal, ()=>{
+        eventsAvailable = true;
+    });
+    setHandler(listenerResolveSignal, ()=>{
+        latchedReason = 'until';
+    });
+    const listenerDeadline = input.continuation?.listenerDeadline ?? initialListenerDeadline(input);
+    let nextSequence;
+    if (input.continuation) {
+        nextSequence = input.continuation.nextSequence;
+    } else {
+        const activated = await activateJobListenerActivity({
+            jobId: input.jobId,
+            expectedVersion: input.jobVersion
+        });
+        if (activated.status === 'terminal') {
+            return {
+                status: runtimeStatusForTerminalJobExecutionStatus(activated.jobStatus),
+                jobVersion: activated.jobVersion
+            };
+        }
+        nextSequence = activated.executionCount + 1;
+    }
+    let firingsInCurrentRun = 0;
+    const maxExecutions = input.maxExecutions ?? undefined;
+    const batchConfig = listenerBatchConfig(input);
+    while(true){
+        if (deadlineReached(listenerDeadline)) latchedReason ??= 'timeout';
+        await continueListenerAsNewIfNeeded({
+            input,
+            nextSequence,
+            latchedReason,
+            listenerDeadline,
+            firingsInCurrentRun
+        });
+        if (latchedReason !== undefined) break;
+        if (maxExecutions !== undefined) {
+            if (nextSequence > maxExecutions) {
+                latchedReason = 'max_executions';
+                await continueListenerAsNewIfNeeded({
+                    input,
+                    nextSequence,
+                    latchedReason,
+                    listenerDeadline,
+                    firingsInCurrentRun
+                });
+                break;
+            }
+        }
+        if (batchConfig !== undefined) {
+            const decision = await awaitBatchFiringWindow({
+                jobId: input.jobId,
+                batchConfig,
+                listenerDeadline,
+                hasEventsHint: ()=>eventsAvailable,
+                clearEventsHint: ()=>{
+                    eventsAvailable = false;
+                },
+                hasResolutionHint: ()=>latchedReason !== undefined
+            });
+            if (decision === 'resolve') {
+                latchedReason ??= 'until';
+                break;
+            }
+            if (decision === 'deadline') {
+                latchedReason ??= 'timeout';
+                break;
+            }
+        }
+        eventsAvailable = false;
+        const drained = await drainListenerEventsActivity({
+            jobId: input.jobId,
+            expectedSequence: nextSequence,
+            ...batchConfig?.maxSizeEvents === undefined ? {} : {
+                maxSize: batchConfig.maxSizeEvents
+            }
+        });
+        if (drained.kind === 'resolve-requested') {
+            latchedReason = 'until';
+            break;
+        }
+        if (drained.kind === 'empty') {
+            const woke = await waitForListenerWakeup(()=>eventsAvailable || latchedReason !== undefined, {
+                deadline: listenerDeadline
+            });
+            if (!woke && deadlineReached(listenerDeadline)) latchedReason = 'timeout';
+            continue;
+        }
+        if (drained.status === 'failed') {
+            await recordListenerFiringOutcomeActivity({
+                outcome: 'failed'
+            });
+            nextSequence = drained.sequence + 1;
+            firingsInCurrentRun += 1;
+            if (maxExecutions !== undefined && drained.sequence >= maxExecutions) {
+                latchedReason = 'max_executions';
+            }
+            continue;
+        }
+        await runListenerExecution({
+            input,
+            jobExecutionId: drained.jobExecutionId,
+            executionVersion: drained.executionVersion,
+            requiredLabels: drained.requiredLabels,
+            shouldCancelForResolution: ()=>input.onResolve === 'cancel' && (latchedReason !== undefined || deadlineReached(listenerDeadline)),
+            waitForResolution: ()=>waitForListenerWakeup(()=>latchedReason !== undefined || deadlineReached(listenerDeadline), {
+                    deadline: listenerDeadline
+                })
+        });
+        if (deadlineReached(listenerDeadline)) latchedReason ??= 'timeout';
+        nextSequence = drained.sequence + 1;
+        firingsInCurrentRun += 1;
+        if (maxExecutions !== undefined && drained.sequence >= maxExecutions) {
+            latchedReason = 'max_executions';
+        }
+    }
+    const reason = latchedReason ?? 'timeout';
+    const resolved = await resolveJobListenerActivity({
+        jobId: input.jobId,
+        reason
+    });
+    return {
+        status: resolved.status,
+        jobVersion: resolved.jobVersion
+    };
+}
+function initialListenerDeadline(input) {
+    return input.listeningTimeoutMs === undefined || input.listeningTimeoutMs === null ? undefined : Date.now() + input.listeningTimeoutMs;
+}
+async function continueListenerAsNewIfNeeded(params) {
+    if (!shouldContinueListenerAsNew({
+        firingsInCurrentRun: params.firingsInCurrentRun,
+        continueAsNewSuggested: workflowInfo().continueAsNewSuggested
+    })) {
+        return;
+    }
+    await continueAsNew(listenerContinuationInput(params.input, {
+        nextSequence: params.nextSequence,
+        latchedReason: params.latchedReason,
+        listenerDeadline: params.listenerDeadline
+    }));
+}
+export function shouldContinueListenerAsNew(params) {
+    return params.continueAsNewSuggested || params.firingsInCurrentRun >= LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT;
+}
+export function listenerContinuationInput(input, continuation) {
+    return {
+        ...input,
+        continuation
+    };
+}
+function listenerBatchConfig(input) {
+    const debounceMs = positiveNumber(input.batchDebounceMs);
+    const maxSizeEvents = positiveNumber(input.batchMaxSize);
+    const maxWaitMs = positiveNumber(input.batchMaxWaitMs);
+    if (debounceMs === undefined && maxSizeEvents === undefined && maxWaitMs === undefined) {
+        return undefined;
+    }
+    return {
+        debounceMs,
+        maxSizeEvents,
+        maxWaitMs
+    };
+}
+async function awaitBatchFiringWindow(params) {
+    while(true){
+        const prePeekDecision = resolutionOrDeadlineDecision(params);
+        if (prePeekDecision !== undefined) return prePeekDecision;
+        const peek = await peekBatchBuffer(params);
+        const peekDecision = bufferedResolveOrDeadlineDecision(params, peek);
+        if (peekDecision !== undefined) return peekDecision;
+        if (peek.fireCount === 0) {
+            const waitDecision = await waitForAnyBatchWakeup(params);
+            if (waitDecision !== undefined) return waitDecision;
+            continue;
+        }
+        if (batchIsReadyToFire(params.batchConfig, peek)) return 'fire';
+        const sleepMs = nextBatchWindowMs(params.batchConfig, peek);
+        if (sleepMs === undefined) {
+            const waitDecision = await waitForAnyBatchWakeup(params);
+            if (waitDecision !== undefined) return waitDecision;
+            continue;
+        }
+        const waitDecision = await waitForBatchWindow(params, sleepMs);
+        if (waitDecision !== undefined) return waitDecision;
+    }
+}
+function resolutionOrDeadlineDecision(params) {
+    if (params.hasResolutionHint()) return 'resolve';
+    if (deadlineReached(params.listenerDeadline)) return 'deadline';
+    return undefined;
+}
+async function peekBatchBuffer(params) {
+    params.clearEventsHint();
+    return await peekListenerBufferActivity({
+        jobId: params.jobId
+    });
+}
+function bufferedResolveOrDeadlineDecision(params, peek) {
+    if (peek.resolvePending || params.hasResolutionHint()) return 'resolve';
+    if (deadlineReached(params.listenerDeadline)) return 'deadline';
+    return undefined;
+}
+function batchIsReadyToFire(config, peek) {
+    const sizeReached = config.maxSizeEvents !== undefined && peek.fireCount >= config.maxSizeEvents;
+    const debounceQuiet = config.debounceMs !== undefined && peek.newestAgeMs >= config.debounceMs;
+    const maxWaitReached = config.maxWaitMs !== undefined && peek.oldestAgeMs >= config.maxWaitMs;
+    return sizeReached || debounceQuiet || maxWaitReached;
+}
+function nextBatchWindowMs(config, peek) {
+    const timeWindows = [
+        remainingWindowMs(config.debounceMs, peek.newestAgeMs),
+        remainingWindowMs(config.maxWaitMs, peek.oldestAgeMs)
+    ].filter((value)=>value !== undefined);
+    return timeWindows.length === 0 ? undefined : Math.min(...timeWindows);
+}
+async function waitForAnyBatchWakeup(params) {
+    const woke = await waitForListenerWakeup(()=>params.hasEventsHint() || params.hasResolutionHint(), {
+        deadline: params.listenerDeadline
+    });
+    if (!woke && deadlineReached(params.listenerDeadline)) return 'deadline';
+    return undefined;
+}
+async function waitForBatchWindow(params, sleepMs) {
+    const deadlineRemaining = remainingMs(params.listenerDeadline);
+    const boundedSleepMs = deadlineRemaining === undefined ? sleepMs : Math.min(sleepMs, deadlineRemaining);
+    const wakesOnEvents = params.batchConfig.debounceMs !== undefined || params.batchConfig.maxSizeEvents !== undefined;
+    const woke = await condition(()=>params.hasResolutionHint() || wakesOnEvents && params.hasEventsHint() || deadlineReached(params.listenerDeadline), boundedSleepMs);
+    if (!woke && deadlineReached(params.listenerDeadline)) return 'deadline';
+    return undefined;
+}
+function positiveNumber(value) {
+    return value === undefined || value === null || value <= 0 ? undefined : value;
+}
+function remainingWindowMs(limitMs, ageMs) {
+    return limitMs === undefined ? undefined : Math.max(0, limitMs - ageMs);
+}
+async function runListenerExecution(params) {
+    const scope = new CancellationScope();
+    const child = scope.run(()=>executeChild(jobExecutionOrchestration, {
+            workflowId: `job:${params.input.jobId}`,
+            workflowIdReusePolicy: 'ALLOW_DUPLICATE',
+            args: [
+                {
+                    workspaceId: params.input.workspaceId,
+                    workflowRunId: params.input.workflowRunId,
+                    projectId: params.input.projectId,
+                    jobId: params.input.jobId,
+                    jobExecutionId: params.jobExecutionId,
+                    runAttemptId: params.input.runAttemptId,
+                    jobVersion: params.input.jobVersion,
+                    executionVersion: params.executionVersion,
+                    ...params.input.executionTimeoutMs === undefined ? {} : {
+                        executionTimeoutMs: params.input.executionTimeoutMs
+                    },
+                    resolveJobStatus: false,
+                    requiredLabels: params.requiredLabels
+                }
+            ],
+            parentClosePolicy: ParentClosePolicy.TERMINATE
+        }));
+    if (params.input.onResolve === 'cancel') {
+        const winner = await Promise.race([
+            child.then(()=>'child', ()=>'child-failed'),
+            params.waitForResolution().then(()=>'resolution')
+        ]);
+        if (winner === 'resolution' && params.shouldCancelForResolution()) {
+            scope.cancel();
+            await settleListenerJobExecutionActivity({
+                jobExecutionId: params.jobExecutionId,
+                status: 'cancelled'
+            });
+            await recordListenerFiringOutcomeActivity({
+                outcome: 'cancelled'
+            });
+            await cancelRunnerJobsActivity({
+                jobIds: [
+                    params.input.jobId
+                ]
+            });
+            return;
+        }
+    }
+    try {
+        const result = await child;
+        await recordListenerFiringOutcomeActivity({
+            outcome: listenerFiringOutcome(result.status)
+        });
+    } catch (error) {
+        log.warn('listener execution child failed; recording failed firing and continuing', {
+            jobId: params.input.jobId,
+            jobExecutionId: params.jobExecutionId,
+            error: String(error)
+        });
+        await settleListenerJobExecutionActivity({
+            jobExecutionId: params.jobExecutionId,
+            status: 'failed'
+        });
+        await recordListenerFiringOutcomeActivity({
+            outcome: 'failed'
+        });
+    }
+}
+function listenerFiringOutcome(status) {
+    if (status === 'succeeded' || status === 'failed' || status === 'cancelled') return status;
+    throw new Error(`Listener execution cannot finish with status: ${status}`);
+}
+async function waitForListenerWakeup(predicate, options) {
+    const remaining = remainingMs(options.deadline);
+    if (remaining !== undefined && remaining <= 0) return false;
+    if (remaining === undefined) {
+        await condition(predicate);
+        return true;
+    }
+    return await condition(predicate, remaining);
+}
+
+//# sourceMappingURL=job-listener-orchestration.js.map

package/dist/temporal/workflows/job-listener-orchestration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/temporal/workflows/job-listener-orchestration.ts"],"sourcesContent":["import {\n  CancellationScope,\n  condition,\n  continueAsNew,\n  defineSignal,\n  executeChild,\n  log,\n  ParentClosePolicy,\n  proxyActivities,\n  setHandler,\n  workflowInfo,\n} from '@temporalio/workflow';\nimport type {ResolutionReason} from '#core/entities/job.js';\nimport {runtimeStatusForTerminalJobExecutionStatus} from '#core/job-execution-outcome.js';\nimport type {RuntimeCompletionStatus} from '#core/workflow-scheduling/runtime-dag.js';\nimport type {createOrchestrationActivities} from '../activities/index.js';\nimport {LISTENER_EVENTS_AVAILABLE_SIGNAL, LISTENER_RESOLVE_SIGNAL} from '../constants.js';\nimport {deadlineReached, remainingMs} from './deadline.js';\nimport {jobExecutionOrchestration} from './job-execution-orchestration.js';\n\nconst {\n  activateJobListenerActivity,\n  drainListenerEventsActivity,\n  peekListenerBufferActivity,\n  resolveJobListenerActivity,\n  settleListenerJobExecutionActivity,\n  recordListenerFiringOutcomeActivity,\n  cancelRunnerJobsActivity,\n} = proxyActivities<ReturnType<typeof createOrchestrationActivities>>({\n  startToCloseTimeout: '30s',\n});\n\nexport const listenerEventsAvailableSignal = defineSignal<[]>(LISTENER_EVENTS_AVAILABLE_SIGNAL);\nexport const listenerResolveSignal = defineSignal<[]>(LISTENER_RESOLVE_SIGNAL);\n\nexport interface JobListenerOrchestrationInput {\n  workspaceId: string;\n  workflowRunId: string;\n  projectId: string;\n  runAttemptId: string;\n  jobId: string;\n  jobVersion: number;\n  requiredLabels: string[];\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  continuation?: ListenerContinuationState | undefined;\n}\n\nexport interface JobListenerOrchestrationResult {\n  status: RuntimeCompletionStatus;\n  jobVersion: number;\n}\n\ntype ResolutionLatch = Exclude<ResolutionReason, 'cancelled'> | undefined;\ntype BatchFiringDecision = 'fire' | 'resolve' | 'deadline';\n\nexport interface ListenerContinuationState {\n  nextSequence: number;\n  latchedReason?: ResolutionLatch;\n  listenerDeadline?: number | undefined;\n}\n\nexport const LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT = 500;\n\ninterface ListenerBatchConfig {\n  debounceMs?: number | undefined;\n  maxSizeEvents?: number | undefined;\n  maxWaitMs?: number | undefined;\n}\n\ninterface BatchFiringWindowParams {\n  jobId: string;\n  batchConfig: ListenerBatchConfig;\n  listenerDeadline: number | undefined;\n  hasEventsHint: () => boolean;\n  clearEventsHint: () => void;\n  hasResolutionHint: () => boolean;\n}\n\ninterface ListenerBufferPeek {\n  fireCount: number;\n  resolvePending: boolean;\n  oldestAgeMs: number;\n  newestAgeMs: number;\n}\n\nexport async function jobListenerOrchestration(\n  input: JobListenerOrchestrationInput,\n): Promise<JobListenerOrchestrationResult> {\n  let eventsAvailable = false;\n  let latchedReason = input.continuation?.latchedReason;\n\n  setHandler(listenerEventsAvailableSignal, () => {\n    eventsAvailable = true;\n  });\n  setHandler(listenerResolveSignal, () => {\n    latchedReason = 'until';\n  });\n\n  const listenerDeadline = input.continuation?.listenerDeadline ?? initialListenerDeadline(input);\n\n  let nextSequence: number;\n  if (input.continuation) {\n    nextSequence = input.continuation.nextSequence;\n  } else {\n    const activated = await activateJobListenerActivity({\n      jobId: input.jobId,\n      expectedVersion: input.jobVersion,\n    });\n    if (activated.status === 'terminal') {\n      return {\n        status: runtimeStatusForTerminalJobExecutionStatus(activated.jobStatus),\n        jobVersion: activated.jobVersion,\n      };\n    }\n    nextSequence = activated.executionCount + 1;\n  }\n\n  let firingsInCurrentRun = 0;\n  const maxExecutions = input.maxExecutions ?? undefined;\n  const batchConfig = listenerBatchConfig(input);\n  while (true) {\n    if (deadlineReached(listenerDeadline)) latchedReason ??= 'timeout';\n    await continueListenerAsNewIfNeeded({\n      input,\n      nextSequence,\n      latchedReason,\n      listenerDeadline,\n      firingsInCurrentRun,\n    });\n    if (latchedReason !== undefined) break;\n    if (maxExecutions !== undefined) {\n      if (nextSequence > maxExecutions) {\n        latchedReason = 'max_executions';\n        await continueListenerAsNewIfNeeded({\n          input,\n          nextSequence,\n          latchedReason,\n          listenerDeadline,\n          firingsInCurrentRun,\n        });\n        break;\n      }\n    }\n\n    if (batchConfig !== undefined) {\n      const decision = await awaitBatchFiringWindow({\n        jobId: input.jobId,\n        batchConfig,\n        listenerDeadline,\n        hasEventsHint: () => eventsAvailable,\n        clearEventsHint: () => {\n          eventsAvailable = false;\n        },\n        hasResolutionHint: () => latchedReason !== undefined,\n      });\n      if (decision === 'resolve') {\n        latchedReason ??= 'until';\n        break;\n      }\n      if (decision === 'deadline') {\n        latchedReason ??= 'timeout';\n        break;\n      }\n    }\n\n    eventsAvailable = false;\n    const drained = await drainListenerEventsActivity({\n      jobId: input.jobId,\n      expectedSequence: nextSequence,\n      ...(batchConfig?.maxSizeEvents === undefined ? {} : {maxSize: batchConfig.maxSizeEvents}),\n    });\n\n    if (drained.kind === 'resolve-requested') {\n      latchedReason = 'until';\n      break;\n    }\n\n    if (drained.kind === 'empty') {\n      const woke = await waitForListenerWakeup(\n        () => eventsAvailable || latchedReason !== undefined,\n        {deadline: listenerDeadline},\n      );\n      if (!woke && deadlineReached(listenerDeadline)) latchedReason = 'timeout';\n      continue;\n    }\n\n    if (drained.status === 'failed') {\n      await recordListenerFiringOutcomeActivity({outcome: 'failed'});\n      nextSequence = drained.sequence + 1;\n      firingsInCurrentRun += 1;\n      if (maxExecutions !== undefined && drained.sequence >= maxExecutions) {\n        latchedReason = 'max_executions';\n      }\n      continue;\n    }\n\n    await runListenerExecution({\n      input,\n      jobExecutionId: drained.jobExecutionId,\n      executionVersion: drained.executionVersion,\n      requiredLabels: drained.requiredLabels,\n      shouldCancelForResolution: () =>\n        input.onResolve === 'cancel' &&\n        (latchedReason !== undefined || deadlineReached(listenerDeadline)),\n      waitForResolution: () =>\n        waitForListenerWakeup(\n          () => latchedReason !== undefined || deadlineReached(listenerDeadline),\n          {deadline: listenerDeadline},\n        ),\n    });\n\n    if (deadlineReached(listenerDeadline)) latchedReason ??= 'timeout';\n    nextSequence = drained.sequence + 1;\n    firingsInCurrentRun += 1;\n    if (maxExecutions !== undefined && drained.sequence >= maxExecutions) {\n      latchedReason = 'max_executions';\n    }\n  }\n\n  const reason = latchedReason ?? 'timeout';\n  const resolved = await resolveJobListenerActivity({jobId: input.jobId, reason});\n  return {status: resolved.status, jobVersion: resolved.jobVersion};\n}\n\nfunction initialListenerDeadline(input: JobListenerOrchestrationInput): number | undefined {\n  return input.listeningTimeoutMs === undefined || input.listeningTimeoutMs === null\n    ? undefined\n    : Date.now() + input.listeningTimeoutMs;\n}\n\nasync function continueListenerAsNewIfNeeded(params: {\n  input: JobListenerOrchestrationInput;\n  nextSequence: number;\n  latchedReason: ResolutionLatch;\n  listenerDeadline: number | undefined;\n  firingsInCurrentRun: number;\n}): Promise<void> {\n  if (\n    !shouldContinueListenerAsNew({\n      firingsInCurrentRun: params.firingsInCurrentRun,\n      continueAsNewSuggested: workflowInfo().continueAsNewSuggested,\n    })\n  ) {\n    return;\n  }\n\n  await continueAsNew<typeof jobListenerOrchestration>(\n    listenerContinuationInput(params.input, {\n      nextSequence: params.nextSequence,\n      latchedReason: params.latchedReason,\n      listenerDeadline: params.listenerDeadline,\n    }),\n  );\n}\n\nexport function shouldContinueListenerAsNew(params: {\n  firingsInCurrentRun: number;\n  continueAsNewSuggested: boolean;\n}): boolean {\n  return (\n    params.continueAsNewSuggested ||\n    params.firingsInCurrentRun >= LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT\n  );\n}\n\nexport function listenerContinuationInput(\n  input: JobListenerOrchestrationInput,\n  continuation: ListenerContinuationState,\n): JobListenerOrchestrationInput {\n  return {...input, continuation};\n}\n\nfunction listenerBatchConfig(\n  input: JobListenerOrchestrationInput,\n): ListenerBatchConfig | undefined {\n  const debounceMs = positiveNumber(input.batchDebounceMs);\n  const maxSizeEvents = positiveNumber(input.batchMaxSize);\n  const maxWaitMs = positiveNumber(input.batchMaxWaitMs);\n  if (debounceMs === undefined && maxSizeEvents === undefined && maxWaitMs === undefined) {\n    return undefined;\n  }\n  return {debounceMs, maxSizeEvents, maxWaitMs};\n}\n\nasync function awaitBatchFiringWindow(\n  params: BatchFiringWindowParams,\n): Promise<BatchFiringDecision> {\n  while (true) {\n    const prePeekDecision = resolutionOrDeadlineDecision(params);\n    if (prePeekDecision !== undefined) return prePeekDecision;\n\n    const peek = await peekBatchBuffer(params);\n    const peekDecision = bufferedResolveOrDeadlineDecision(params, peek);\n    if (peekDecision !== undefined) return peekDecision;\n\n    if (peek.fireCount === 0) {\n      const waitDecision = await waitForAnyBatchWakeup(params);\n      if (waitDecision !== undefined) return waitDecision;\n      continue;\n    }\n\n    if (batchIsReadyToFire(params.batchConfig, peek)) return 'fire';\n\n    const sleepMs = nextBatchWindowMs(params.batchConfig, peek);\n    if (sleepMs === undefined) {\n      const waitDecision = await waitForAnyBatchWakeup(params);\n      if (waitDecision !== undefined) return waitDecision;\n      continue;\n    }\n\n    const waitDecision = await waitForBatchWindow(params, sleepMs);\n    if (waitDecision !== undefined) return waitDecision;\n  }\n}\n\nfunction resolutionOrDeadlineDecision(\n  params: BatchFiringWindowParams,\n): Exclude<BatchFiringDecision, 'fire'> | undefined {\n  if (params.hasResolutionHint()) return 'resolve';\n  if (deadlineReached(params.listenerDeadline)) return 'deadline';\n  return undefined;\n}\n\nasync function peekBatchBuffer(params: BatchFiringWindowParams): Promise<ListenerBufferPeek> {\n  params.clearEventsHint();\n  return await peekListenerBufferActivity({jobId: params.jobId});\n}\n\nfunction bufferedResolveOrDeadlineDecision(\n  params: BatchFiringWindowParams,\n  peek: ListenerBufferPeek,\n): Exclude<BatchFiringDecision, 'fire'> | undefined {\n  if (peek.resolvePending || params.hasResolutionHint()) return 'resolve';\n  if (deadlineReached(params.listenerDeadline)) return 'deadline';\n  return undefined;\n}\n\nfunction batchIsReadyToFire(config: ListenerBatchConfig, peek: ListenerBufferPeek): boolean {\n  const sizeReached = config.maxSizeEvents !== undefined && peek.fireCount >= config.maxSizeEvents;\n  const debounceQuiet = config.debounceMs !== undefined && peek.newestAgeMs >= config.debounceMs;\n  const maxWaitReached = config.maxWaitMs !== undefined && peek.oldestAgeMs >= config.maxWaitMs;\n  return sizeReached || debounceQuiet || maxWaitReached;\n}\n\nfunction nextBatchWindowMs(\n  config: ListenerBatchConfig,\n  peek: ListenerBufferPeek,\n): number | undefined {\n  const timeWindows = [\n    remainingWindowMs(config.debounceMs, peek.newestAgeMs),\n    remainingWindowMs(config.maxWaitMs, peek.oldestAgeMs),\n  ].filter((value): value is number => value !== undefined);\n  return timeWindows.length === 0 ? undefined : Math.min(...timeWindows);\n}\n\nasync function waitForAnyBatchWakeup(\n  params: BatchFiringWindowParams,\n): Promise<Exclude<BatchFiringDecision, 'fire'> | undefined> {\n  const woke = await waitForListenerWakeup(\n    () => params.hasEventsHint() || params.hasResolutionHint(),\n    {deadline: params.listenerDeadline},\n  );\n  if (!woke && deadlineReached(params.listenerDeadline)) return 'deadline';\n  return undefined;\n}\n\nasync function waitForBatchWindow(\n  params: BatchFiringWindowParams,\n  sleepMs: number,\n): Promise<Exclude<BatchFiringDecision, 'fire'> | undefined> {\n  const deadlineRemaining = remainingMs(params.listenerDeadline);\n  const boundedSleepMs =\n    deadlineRemaining === undefined ? sleepMs : Math.min(sleepMs, deadlineRemaining);\n  const wakesOnEvents =\n    params.batchConfig.debounceMs !== undefined || params.batchConfig.maxSizeEvents !== undefined;\n  const woke = await condition(\n    () =>\n      params.hasResolutionHint() ||\n      (wakesOnEvents && params.hasEventsHint()) ||\n      deadlineReached(params.listenerDeadline),\n    boundedSleepMs,\n  );\n  if (!woke && deadlineReached(params.listenerDeadline)) return 'deadline';\n  return undefined;\n}\n\nfunction positiveNumber(value: number | null | undefined): number | undefined {\n  return value === undefined || value === null || value <= 0 ? undefined : value;\n}\n\nfunction remainingWindowMs(limitMs: number | undefined, ageMs: number): number | undefined {\n  return limitMs === undefined ? undefined : Math.max(0, limitMs - ageMs);\n}\n\nasync function runListenerExecution(params: {\n  input: JobListenerOrchestrationInput;\n  jobExecutionId: string;\n  executionVersion: number;\n  requiredLabels: string[];\n  shouldCancelForResolution: () => boolean;\n  waitForResolution: () => Promise<boolean>;\n}): Promise<void> {\n  const scope = new CancellationScope();\n  const child = scope.run(() =>\n    executeChild(jobExecutionOrchestration, {\n      workflowId: `job:${params.input.jobId}`,\n      workflowIdReusePolicy: 'ALLOW_DUPLICATE',\n      args: [\n        {\n          workspaceId: params.input.workspaceId,\n          workflowRunId: params.input.workflowRunId,\n          projectId: params.input.projectId,\n          jobId: params.input.jobId,\n          jobExecutionId: params.jobExecutionId,\n          runAttemptId: params.input.runAttemptId,\n          jobVersion: params.input.jobVersion,\n          executionVersion: params.executionVersion,\n          ...(params.input.executionTimeoutMs === undefined\n            ? {}\n            : {executionTimeoutMs: params.input.executionTimeoutMs}),\n          resolveJobStatus: false,\n          requiredLabels: params.requiredLabels,\n        },\n      ],\n      parentClosePolicy: ParentClosePolicy.TERMINATE,\n    }),\n  );\n\n  if (params.input.onResolve === 'cancel') {\n    const winner = await Promise.race([\n      child.then(\n        () => 'child' as const,\n        () => 'child-failed' as const,\n      ),\n      params.waitForResolution().then(() => 'resolution' as const),\n    ]);\n    if (winner === 'resolution' && params.shouldCancelForResolution()) {\n      scope.cancel();\n      await settleListenerJobExecutionActivity({\n        jobExecutionId: params.jobExecutionId,\n        status: 'cancelled',\n      });\n      await recordListenerFiringOutcomeActivity({outcome: 'cancelled'});\n      await cancelRunnerJobsActivity({jobIds: [params.input.jobId]});\n      return;\n    }\n  }\n\n  try {\n    const result = await child;\n    await recordListenerFiringOutcomeActivity({outcome: listenerFiringOutcome(result.status)});\n  } catch (error) {\n    log.warn('listener execution child failed; recording failed firing and continuing', {\n      jobId: params.input.jobId,\n      jobExecutionId: params.jobExecutionId,\n      error: String(error),\n    });\n    await settleListenerJobExecutionActivity({\n      jobExecutionId: params.jobExecutionId,\n      status: 'failed',\n    });\n    await recordListenerFiringOutcomeActivity({outcome: 'failed'});\n  }\n}\n\nfunction listenerFiringOutcome(\n  status: RuntimeCompletionStatus,\n): 'succeeded' | 'failed' | 'cancelled' {\n  if (status === 'succeeded' || status === 'failed' || status === 'cancelled') return status;\n  throw new Error(`Listener execution cannot finish with status: ${status}`);\n}\n\nasync function waitForListenerWakeup(\n  predicate: () => boolean,\n  options: {deadline: number | undefined},\n): Promise<boolean> {\n  const remaining = remainingMs(options.deadline);\n  if (remaining !== undefined && remaining <= 0) return false;\n  if (remaining === undefined) {\n    await condition(predicate);\n    return true;\n  }\n  return await condition(predicate, remaining);\n}\n"],"names":["CancellationScope","condition","continueAsNew","defineSignal","executeChild","log","ParentClosePolicy","proxyActivities","setHandler","workflowInfo","runtimeStatusForTerminalJobExecutionStatus","LISTENER_EVENTS_AVAILABLE_SIGNAL","LISTENER_RESOLVE_SIGNAL","deadlineReached","remainingMs","jobExecutionOrchestration","activateJobListenerActivity","drainListenerEventsActivity","peekListenerBufferActivity","resolveJobListenerActivity","settleListenerJobExecutionActivity","recordListenerFiringOutcomeActivity","cancelRunnerJobsActivity","startToCloseTimeout","listenerEventsAvailableSignal","listenerResolveSignal","LISTENER_CONTINUE_AS_NEW_FIRING_LIMIT","jobListenerOrchestration","input","eventsAvailable","latchedReason","continuation","listenerDeadline","initialListenerDeadline","nextSequence","activated","jobId","expectedVersion","jobVersion","status","jobStatus","executionCount","firingsInCurrentRun","maxExecutions","undefined","batchConfig","listenerBatchConfig","continueListenerAsNewIfNeeded","decision","awaitBatchFiringWindow","hasEventsHint","clearEventsHint","hasResolutionHint","drained","expectedSequence","maxSizeEvents","maxSize","kind","woke","waitForListenerWakeup","deadline","outcome","sequence","runListenerExecution","jobExecutionId","executionVersion","requiredLabels","shouldCancelForResolution","onResolve","waitForResolution","reason","resolved","listeningTimeoutMs","Date","now","params","shouldContinueListenerAsNew","continueAsNewSuggested","listenerContinuationInput","debounceMs","positiveNumber","batchDebounceMs","batchMaxSize","maxWaitMs","batchMaxWaitMs","prePeekDecision","resolutionOrDeadlineDecision","peek","peekBatchBuffer","peekDecision","bufferedResolveOrDeadlineDecision","fireCount","waitDecision","waitForAnyBatchWakeup","batchIsReadyToFire","sleepMs","nextBatchWindowMs","waitForBatchWindow","resolvePending","config","sizeReached","debounceQuiet","newestAgeMs","maxWaitReached","oldestAgeMs","timeWindows","remainingWindowMs","filter","value","length","Math","min","deadlineRemaining","boundedSleepMs","wakesOnEvents","limitMs","ageMs","max","scope","child","run","workflowId","workflowIdReusePolicy","args","workspaceId","workflowRunId","projectId","runAttemptId","executionTimeoutMs","resolveJobStatus","parentClosePolicy","TERMINATE","winner","Promise","race","then","cancel","jobIds","result","listenerFiringOutcome","error","warn","String","Error","predicate","options","remaining"],"mappings":"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"}

package/dist/temporal/workflows/run-orchestration.d.ts

@@ -0,0 +1,8 @@
+export declare const runCancelSignal: import("@temporalio/workflow").SignalDefinition<[], string>;
+export interface RunOrchestrationInput {
+    workflowRunId: string;
+    runAttemptId: string;
+    workspaceId: string;
+}
+export declare function runOrchestration(input: RunOrchestrationInput): Promise<void>;
+//# sourceMappingURL=run-orchestration.d.ts.map

package/dist/temporal/workflows/run-orchestration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-orchestration.d.ts","sourceRoot":"","sources":["../../../src/temporal/workflows/run-orchestration.ts"],"names":[],"mappings":"AA6CA,eAAO,MAAM,eAAe,6DAAsC,CAAC;AAEnE,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CAwGlF"}