worker

type DurableEvictionHook interface {
	// MarkWaiting signals that the run identified by key has entered a waiting state.
	// waitKind describes what the run is waiting on; resourceID is an opaque identifier
	// (e.g. signal key, event key, child workflow name) useful for logging.
	MarkWaiting(key, waitKind, resourceID string)

	// MarkActive signals that the run identified by key has exited a waiting state.
	// It is reference-counted against MarkWaiting calls with the same key.
	MarkActive(key string)
}

type DurableHatchetContext interface {
	HatchetContext

	// SleepFor pauses execution for the specified duration and returns after that time has elapsed.
	// Duration is "global" meaning it will wait in real time regardless of transient failures
	// like worker restarts.
	SleepFor(duration time.Duration) (*SingleWaitResult, error)

	// WaitForEvent pauses execution until the specified user event is received.
	// Options such as condition.WithEventScope and condition.WithConsiderEventsSince
	// can be used to scope the wait and match events pushed before the wait started.
	WaitForEvent(eventKey, expression string, opts ...condition.UserEventConditionOpt) (*SingleWaitResult, error)

	// WaitFor pauses execution until the specified conditions are met.
	// Conditions are "global" meaning they will wait in real time regardless of transient failures
	// like worker restarts.
	WaitFor(conditions condition.Condition) (*WaitResult, error)

	// Memo executes fn, JSON-serializes the result, and persists it via the engine's
	// durable event log. On replay, the cached payload is returned without re-executing
	// fn. Callers should json.Unmarshal the returned bytes into their concrete type.
	// If the engine does not support durable memoization, fn is executed and the result
	// is cached in process only (it will not survive replay).
	// The key must be unique within the task.
	Memo(key string, fn func() (any, error)) (json.RawMessage, error)

	// Now returns the current time, memoized via Memo so replays return the same value.
	Now() (time.Time, error)

	// InvocationCount returns the current invocation count for this durable task.
	// Increments each time the task is started (including after eviction/restore).
	InvocationCount() int32

	// SleepUntil sleeps until the specified absolute time. Combines Now() with SleepFor.
	SleepUntil(t time.Time) (*SingleWaitResult, error)
}

type ErrMarshalKeyNotFound struct {
	Key string
}

type HatchetContext interface {
	context.Context

	// SetContext replaces the underlying context.Context, for example to attach a deadline.
	SetContext(ctx context.Context)

	// GetContext returns the underlying context.Context.
	GetContext() context.Context

	// Worker returns the worker executing the task, which exposes its ID, labels, and
	// registered workflows.
	Worker() HatchetWorkerContext

	// StepOutput decodes the output of the named upstream step into target, which must
	// be a pointer. Prefer ParentOutput, which takes a task reference instead of a name.
	StepOutput(step string, target interface{}) error

	// TriggerDataKeys lists the keys available to TriggerData.
	TriggerDataKeys() []string

	// TriggerData decodes the payload of a matched trigger condition (such as a wait-for
	// event) into target, which must be a pointer.
	TriggerData(key string, target interface{}) error

	// StepRunErrors returns the errors of upstream task runs, keyed by task name.
	// Intended for use in an on-failure task.
	StepRunErrors() map[string]string

	// TriggeredByEvent reports whether the current run was triggered by an event.
	TriggeredByEvent() bool

	// WorkflowInput decodes the workflow input into target, which must be a pointer.
	// Prefer the typed input argument passed to the task function.
	WorkflowInput(target interface{}) error

	// BatchInputInto decodes the buffered items of a batch task's START_BATCH action into
	// target, which must be a pointer. The decoded value is a map keyed by each buffered
	// item's task run external id.
	BatchInputInto(target interface{}) error

	// UserData decodes the user data attached to the step into target, which must be a
	// pointer.
	UserData(target interface{}) error

	// AdditionalMetadata returns the additional metadata sent with the current run.
	AdditionalMetadata() map[string]string

	// StepName returns the name of the currently running task.
	StepName() string

	// StepRunId returns the ID of the current task run.
	StepRunId() string

	// StepId returns the ID of the step (the task declaration, not the run).
	StepId() string

	// WorkflowRunId returns the ID of the current workflow run.
	WorkflowRunId() string

	// WorkflowId returns the ID of the workflow this task belongs to, or nil if unknown.
	WorkflowId() *string

	// WorkflowVersionId returns the ID of the workflow version this task belongs to, or
	// nil if unknown.
	WorkflowVersionId() *string

	// Log sends a log line to the Hatchet API for the current task run.
	Log(message string)

	// StreamEvent sends a raw stream event for the current task run, which separate
	// consumers can subscribe to.
	StreamEvent(message []byte)

	// PutStream sends a stream event for the current task run, which separate consumers
	// can subscribe to.
	PutStream(message string)

	// SpawnWorkflow triggers a child workflow run from within the current task. Prefer
	// passing this context to a workflow's Run method, which spawns a child run
	// automatically.
	SpawnWorkflow(workflowName string, input any, opts *SpawnWorkflowOpts) (*client.Workflow, error)

	// SpawnWorkflows triggers multiple child workflow runs from within the current task.
	SpawnWorkflows(childWorkflows []*SpawnWorkflowsOpts) ([]*client.Workflow, error)

	// ReleaseSlot manually releases the worker slot held by the current task run to free
	// up capacity. Advanced feature; use with caution.
	ReleaseSlot() error

	// RefreshTimeout extends the execution timeout of the current task run by the given
	// duration string, such as "5m".
	RefreshTimeout(incrementTimeoutBy string) error

	// RetryCount returns the number of times the current task run has been retried.
	RetryCount() int

	// ParentOutput decodes the output of a parent task into output, which must be a
	// pointer. Pass the task reference returned by NewTask.
	ParentOutput(parent create.NamedTask, output interface{}) error

	// WasSkipped reports whether the given parent task was skipped.
	WasSkipped(parent create.NamedTask) bool

	// TenantId returns the ID of the tenant the run is executing in.
	TenantId() string

	// WorkerId returns the ID of the worker executing the task.
	WorkerId() string

	// ActionId returns the action ID of the currently running task.
	ActionId() string

	// DurableTaskInvocationCount returns the invocation count for durable task replay tracking.
	// Returns 0 if not set (non-durable tasks).
	DurableTaskInvocationCount() int32

	// CurChildIndex returns the index that will be assigned to the next spawned child
	// workflow. For internal use by the SDK's child workflow bookkeeping.
	CurChildIndex() int
	// IncChildIndex increments the child workflow index. For internal use by the SDK's
	// child workflow bookkeeping.
	IncChildIndex()

	// Priority returns the priority the current run was triggered with.
	Priority() int32

	// FilterPayload returns the payload of the event filter that matched, if the run was
	// triggered through a filter.
	FilterPayload() map[string]interface{}

	// ParentWorkflowRunId returns the workflow run ID of the parent run, if this run was
	// spawned as a child workflow.
	ParentWorkflowRunId() *string

	// ChildIndex returns the index of this run among its parent's child workflow runs,
	// if applicable.
	ChildIndex() *int32

	// ChildKey returns the deduplication key this run was spawned with, if applicable.
	ChildKey() *string

	// TriggeringEventId returns the ID of the event that triggered this run, if it was
	// triggered by an event.
	TriggeringEventId() *string

	// TriggeringEventKey returns the key of the event that triggered this run, if it was
	// triggered by an event.
	TriggeringEventKey() *string
	// contains filtered or unexported methods
}

type HatchetWorkerContext interface {
	context.Context

	SetContext(ctx context.Context)

	GetContext() context.Context

	ID() string

	GetLabels() map[string]interface{}

	UpsertLabels(labels map[string]interface{}) error

	HasWorkflow(workflowName string) bool
}

type SingleWaitResult struct {
	*WaitResult
	// contains filtered or unexported fields
}

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