workflow

type AppError = jobdb.AppError

type AppErrorOutcome = jobdb.AppErrorOutcome

type AppErrorPayload = jobdb.AppErrorPayload

type ApplicationInputBytes = jobdb.ApplicationInputBytes

type ApplicationOutputBytes = jobdb.ApplicationOutputBytes

type ApplicationOutputOutcome = jobdb.ApplicationOutputOutcome

type Artifact = jobdb.Artifact

type ArtifactInfo = jobdb.ArtifactInfo

type ArtifactKey = jobdb.ArtifactKey

type ArtifactReader = jobdb.ArtifactReader

type ArtifactRef = jobdb.ArtifactRef

type ArtifactUpload = jobdb.ArtifactUpload

type CancelJob = jobdb.CancelJob

type CancelJobRequest = jobdb.CancelJobRequest

type CatchDisposition string

type CatchResult struct {
	Disposition CatchDisposition
	Output      TaskData
	Err         error
}

type CatchRule struct {
	ID     string
	Match  func(error) bool
	Handle func(ExecutionContext, error) (CatchResult, error)
}

type Chapter = jobdb.Chapter

type ChapterBody = jobdb.ChapterBody

type ChapterMetadata = jobdb.ChapterMetadata

type ChapterMetadataKind = jobdb.ChapterMetadataKind

type ChapterMetadataValue = jobdb.ChapterMetadataValue

type ChapterOutcome = jobdb.ChapterOutcome

type ChapterRef = jobdb.ChapterRef

type ClientPayloadUpdate = jobdb.ClientPayloadUpdate

type CompleteExecutionRequest = jobdb.CompleteExecutionRequest

type CompleteTaskIfWaitingRequest = jobdb.CompleteTaskIfWaitingRequest

type ConfigurationSnapshot = jobdb.ConfigurationSnapshot

type Data = jobdb.Data

type Duration = jobdb.Duration

type Engine interface {
	RegisterWorkers(workset *WorkSet) error
	GetArtifact(tenantId string, key ArtifactKey) (Artifact, error)
	// contains filtered or unexported methods
}

type EngineBuilder struct {
	// contains filtered or unexported fields
}

type EnvelopedTaskData = jobdb.EnvelopedTaskData

type ExecutionChapter = jobdb.ExecutionChapter

type ExecutionContext interface {
	Context() context.Context
	GetJobKey() JobKey
	Logger() *slog.Logger
	ExecutionVersions() jobdb.ExecutionVersions
	DoTask(TaskCall, func(context.Context) (TaskData, error)) (TaskData, error)
	DoScope(string, ScopeOptions, func(ExecutionContext) (JobData, error)) (JobData, error)
	AwaitDuration(Duration) error
	AwaitJobs(...string) error
	GetConfiguration(context.Context) (ConfigurationSnapshot, error)
	ResolveSecrets(context.Context, []string) (SecretResolveResult, error)
	ClientPayload() json.RawMessage
	ClientPayloadRevision() int64
	SubmitJob(context.Context, SubmitJob) (JobKey, error)
	SubmitRestartJob(context.Context, SubmitRestartJob) (JobKey, error)
	// Yield reschedules and stops execution. Read JobRunOutcome.Handoff after
	// Run returns for confirmation; post-Yield user code may still be running.
	Yield(context.Context, YieldRequest) error
}

type ExecutionLease = jobdb.ExecutionLease

type ExecutionState = jobdb.ExecutionState

type ExecutionWorker struct {
	JobType string
	Execute func(ExecutionContext, JobData) (JobData, error)
}

type FieldName = jobdb.FieldName

type FindTasksWaitingRequest struct {
	JobType        string
	TaskType       string
	TenantIds      []string
	MetadataFilter MetadataFilter
	Limit          int
}

type GetJobForRunRequest struct {
	ConsumerVersions map[string]string
	// BeforeRun runs under the validated, renewing lease before application work.
	// It may reschedule the supplied lease to reject execution admission.
	BeforeRun     func(context.Context, ExecutionLease) error
	JobKey        JobKey
	JobWorker     JobWorker
	TaskWorkers   []TaskWorker
	WorkerID      string
	LeaseDuration time.Duration
	Logger        *slog.Logger

	// If the job awaits longer than this, the lease is rescheduled instead of
	// sleeping inline. Zero uses the existing default behavior.
	AwaitThreshold time.Duration
}

type GetJobLeaseRequest = jobdb.GetJobLeaseRequest

type GetJobRunRequest = jobdb.GetJobRunRequest

type GetJobRunResponse = jobdb.GetJobRunResponse

type Handoff struct {
	NextRoute Route
	Metadata  json.RawMessage
}

type InputReference = jobdb.InputReference

type JobAttempt = jobdb.JobAttempt

type JobAttemptOutcomeChapter = jobdb.JobAttemptOutcomeChapter

type JobContext interface {
	// GetConfiguration returns a copy of the first successful tenant snapshot in
	// this live job attempt. Tasks share the same cache; whole-job retries reset it.
	GetConfiguration(context.Context) (ConfigurationSnapshot, error)
	// ResolveSecrets retrieves allowed names under this invocation's live lease.
	// Values and omissions are cached by name for this live job attempt, never
	// recorded. New names refresh all cached available names together; known omissions
	// are not retried. Offline replay rejects reads;
	// use task-level resolution for workflows that must support offline replay.
	ResolveSecrets(context.Context, []string) (SecretResolveResult, error)
	ClientPayload() json.RawMessage
	ClientPayloadRevision() int64
	// Yield reschedules and stops this invocation. It never writes a chapter.
	Yield(context.Context, YieldRequest) error
	GetJobKey() JobKey
	Logger() *slog.Logger
	DoTask(policy RunPolicy, taskType string, data TaskData) (TaskData, error)
	AwaitDuration(waitFor Duration) error
	AwaitJobs(jobIds ...string) error
	SubmitJob(ctx context.Context, submit SubmitJob) (JobKey, error)
	SubmitRestartJob(ctx context.Context, restart SubmitRestartJob) (JobKey, error)
}

type JobData = jobdb.TaskData

type JobEndEvent struct {
	JobKey        JobKey
	AttemptNumber int
	Output        JobData
	Err           error
	At            time.Time
}

type JobFailedError = jobdb.JobFailedError

type JobHandle = jobdb.JobHandle

type JobInfo = jobdb.JobInfo

type JobKey = jobdb.JobKey

type JobPrereqCondition = jobdb.JobPrereqCondition

type JobPrerequisite = jobdb.JobPrerequisite

type JobRunListener interface {
	OnJobStart(event JobStartEvent)
	OnTaskStart(event TaskStartEvent)
	OnTaskEnd(event TaskEndEvent)
	OnJobEnd(event JobEndEvent)
}

type JobRunOutcome struct {
	// Handoff is set only for an explicit Yield acknowledged during this Run.
	// Read it after Run returns; no task callback needs to finish first.
	Handoff       *Handoff
	Status        JobRunStatus
	LeaseAcquired bool

	// Set when Status == COMPLETED.
	Output JobData

	// Set when Status == FAILED.
	JobError error

	// Best-effort job state details, mainly useful when Status == SUSPENDED
	// or NOT_LEASEABLE. For a confirmed handoff, NextRoute is the acknowledged
	// route; these fields are not refreshed from the scheduler.
	JobStatus     *JobStatus
	NextRoute     *Route
	WaitForJobIDs []string
	MissingRoute  *Route
}

type JobRunStatus string

type JobRunSummary = jobdb.JobRunSummary

type JobRunnable struct {
	// contains filtered or unexported fields
}

type JobStart = jobdb.JobStart

type JobStartChapter = jobdb.JobStartChapter

type JobStartEvent struct {
	JobKey        JobKey
	AttemptNumber int
	Input         JobData
	At            time.Time
}

type JobStatus = jobdb.JobStatus

type JobStore = jobdb.JobStore

type JobSummary = jobdb.JobSummary

type JobTaskFilter = jobdb.JobTaskFilter

type JobWorker interface {
	Name() string
	Run(JobContext, JobData) (JobData, error)
}

type ListChaptersRequest = jobdb.ListChaptersRequest

type ListJobsRequest = jobdb.ListJobsRequest

type ListJobsResponse = jobdb.ListJobsResponse

type ListScheduleRunsRequest = jobdb.ListScheduleRunsRequest

type ListScheduleRunsResponse = jobdb.ListScheduleRunsResponse

type ListSchedulesRequest = jobdb.ListSchedulesRequest

type ListSchedulesResponse = jobdb.ListSchedulesResponse

type MetadataFilter = jobdb.MetadataFilter

type MetadataPredicate = jobdb.MetadataPredicate

type NonRetryableError = jobdb.NonRetryableError

type PollWorkRequest = jobdb.PollWorkRequest

type PutChapterRequest = jobdb.PutChapterRequest

type ReplayCacheMissError struct {
	JobKey   JobKey
	TaskType string
	Ordinal  int64
	Attempt  int
	Reason   ReplayCacheMissReason
}

type ReplayCacheMissReason string

type ReplayObserver interface {
	OnJobStart(event JobStartEvent)
	OnTaskStart(event TaskStartEvent)
	OnTaskEnd(event TaskEndEvent)
	OnJobEnd(event JobEndEvent)
}

type ReplayRunRequest struct {
	JobKey   JobKey
	Observer ReplayObserver // optional

	// Optional job worker override for replay-time instrumentation.
	// If nil, the registered job worker is used.
	JobWorker JobWorker
}

type RescheduleExecutionRequest = jobdb.RescheduleExecutionRequest

type RestartExtraChapter = jobdb.RestartExtraChapter

type RetryPolicy = jobdb.RetryPolicy

type Route = jobdb.Route

type RunPolicy = jobdb.RunPolicy

type RuntimeBuildOptions struct {
	Logger                *slog.Logger
	MaxActive             int
	AwaitRecycleThreshold time.Duration
	PollTenantId          string
}

type ScheduleFailurePolicy = jobdb.ScheduleFailurePolicy

type ScheduleInfo = jobdb.ScheduleInfo

type ScheduleKey = jobdb.ScheduleKey

type ScheduleMutationRequest = jobdb.ScheduleMutationRequest

type ScheduleOverlapPolicy = jobdb.ScheduleOverlapPolicy

type ScheduleRunSummary = jobdb.ScheduleRunSummary

type ScheduleSpec = jobdb.ScheduleSpec

type ScheduleState = jobdb.ScheduleState

type ScheduleTarget = jobdb.ScheduleTarget

type ScheduleTrigger = jobdb.ScheduleTrigger

type ScheduleTriggerKind = jobdb.ScheduleTriggerKind

type ScopeOptions struct {
	TotalTimeout   time.Duration
	AttemptTimeout time.Duration
	Retry          RetryPolicy
	Catch          []CatchRule
	// OnRestart runs with fresh consumer state before the selected scope body.
	OnRestart func(json.RawMessage) error
}

type SecretResolveResult = jobdb.SecretResolveResult

type SecretValue = jobdb.SecretValue

type SimpleTaskData = jobdb.SimpleTaskData

type StoredArtifact = jobdb.StoredArtifact

type SubmitJob = jobdb.SubmitJob

type SubmitJobRequest = jobdb.SubmitJobRequest

type SubmitRestartJob = jobdb.SubmitRestartJob

type SubmitRestartJobRequest = jobdb.SubmitRestartJobRequest

type SystemError = jobdb.SystemError

type SystemErrorOutcome = jobdb.SystemErrorOutcome

type SystemErrorPayload = jobdb.SystemErrorPayload

type TaskAlternate struct {
	TaskType string    `json:"taskType"`
	At       time.Time `json:"at"`
}

type TaskAlternateAfter struct {
	TaskType string        `json:"task_type"`
	After    time.Duration `json:"after"`
}

type TaskAttempt = jobdb.TaskAttempt

type TaskAttemptOutcomeChapter = jobdb.TaskAttemptOutcomeChapter

type TaskCall struct {
	Site            string              `json:"site"`
	TaskType        string              `json:"task_type"`
	ContractVersion uint32              `json:"contract_version"`
	Command         json.RawMessage     `json:"command"`
	Policy          RunPolicy           `json:"policy"`
	Catch           []CatchRule         `json:"-"`
	Alternate       *TaskAlternateAfter `json:"alternate,omitempty"`
}

type TaskCompletion struct {
	JobKey JobKey
	Step   int64
	Error  error
}

type TaskContext struct {
	JobKey JobKey
	// Step is the outcome ordinal for this call to Run. In the versioned
	// engine it remains valid across in-process waits. Suspension or lease loss
	// ends the call; a resumed Run gets a new context and may have a new Step.
	Step int64
	// InvocationID identifies the logical task within JobKey in the versioned
	// engine. It survives task retries and recovery, but changes when an enclosing
	// scope or whole job retries. It is empty for the legacy JobWorker engine.
	InvocationID string
	// AttemptNumber is one-based in the versioned engine. Recovery of unfinished
	// work retains the attempt; a task retry increments it. Legacy contexts use 0.
	AttemptNumber int
	Logger        *slog.Logger
	// contains filtered or unexported fields
}

type TaskData = jobdb.TaskData

type TaskDeterminismMeta struct {
	Ordinal       int64           `json:"ordinal"`
	TaskType      string          `json:"task_type"`
	WorkerID      string          `json:"worker_id,omitempty"`
	CreatedAt     time.Time       `json:"created_at,omitempty"`
	Attempt       int             `json:"attempt,omitempty"`
	MaxAttempts   int             `json:"max_attempts,omitempty"`
	NextAttemptAt *time.Time      `json:"next_attempt_at,omitempty"`
	BackoffMillis int64           `json:"backoff_ms,omitempty"`
	Retryable     *bool           `json:"retryable,omitempty"`
	InputHash     string          `json:"input_hash,omitempty"`
	InputRef      *InputReference `json:"input_ref,omitempty"`
	RunPolicy     *RunPolicy      `json:"run_policy,omitempty"`
	InputPayload  json.RawMessage `json:"input_payload,omitempty"`
	Version       int             `json:"version,omitempty"`
}

type TaskEndEvent struct {
	InvocationID  string
	JobKey        JobKey
	TaskType      string
	Ordinal       int64
	AttemptNumber int
	Output        TaskData
	Err           error
	At            time.Time
}

type TaskError = jobdb.TaskError

type TaskHandle interface {
	JobKey() JobKey
	Data() (TaskData, error)
	Finish(ctx context.Context, taskData TaskData) error
	TaskOrdinalToComplete() int64
	TaskType() string
	CreatedAt() time.Time
	Metadata() json.RawMessage
}

type TaskIO = jobdb.TaskIO

type TaskInputMismatchError struct {
	TaskType          string
	Ordinal           int64
	CachedInputHash   string
	ComputedInputHash string
	CachedInput       json.RawMessage
	CachedOutput      TaskData
	CachedOutputErr   error
	Meta              TaskDeterminismMeta
}

type TaskOptions struct {
	Alternate *TaskAlternate `json:"alternate,omitempty"`
}

type TaskOutcome = jobdb.TaskOutcome

type TaskRun = jobdb.TaskRun

type TaskRuntime = jobdb.TaskRuntime

type TaskStartEvent struct {
	InvocationID  string
	JobKey        JobKey
	TaskType      string
	Ordinal       int64
	AttemptNumber int
	Input         TaskData
	At            time.Time
}

type TaskWait = jobdb.TaskWait

type TaskWorker interface {
	Name() string
	Run(context TaskContext, input TaskData) (TaskData, error)
}

type TimeoutError = jobdb.TimeoutError

type TimeoutOutcome = jobdb.TimeoutOutcome

type TimeoutPayload = jobdb.TimeoutPayload

type TriggerScheduleRequest = jobdb.TriggerScheduleRequest

type UpsertScheduleRequest = jobdb.UpsertScheduleRequest

type WorkRegistrationOptions struct {
	ConsumerVersions map[string]string
	MetadataFilter   MetadataFilter
}

type WorkSet struct {
	JobWorker   JobWorker
	TaskWorkers map[string]TaskWorker
	Options     WorkRegistrationOptions
	// contains filtered or unexported fields
}

type Worker interface {
	// contains filtered or unexported methods
}

type WorkflowRuntime = jobdb.WorkflowRuntime

type YieldRequest struct {
	Reschedule RescheduleExecutionRequest
	Metadata   json.RawMessage
}