flowtest

type AutoFlowStart struct {
	Script []byte
	// ChannelArgs names the channel-typed arguments passed with the start
	// request. Only these channels are externally sendable: channel tokens
	// are minted for channels the caller passes in, never for channels the
	// flow creates itself.
	ChannelArgs []string
}

type AutocoreStart struct {
	Workflow string
	Input    proto.Message
}

type AutocoreTarget struct {
	Client              autocore.Client
	ExternalNamespaceID autocore.ExternalNamespaceID
}

type CancelOp struct{}

type CompositeTarget struct {
	Autocore Target
	AutoFlow Target
}

type DriveOp struct {
	At     time.Duration
	Send   *SendOp
	Cancel *CancelOp
}

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

type DriverConfig struct {
	Log     *slog.Logger
	Target  Target
	Sources []WeightedSource
	Rate    RateModel
	// RNG drives source picking and unit generation. Seeded per replica so
	// replicas produce independent unit streams.
	RNG *rand.Rand
	// MaxInFlightSessions bounds concurrently running sessions. New arrivals
	// are skipped at the bound: the driver stays open-loop, so a saturated
	// target surfaces as skipped sessions rather than as silently stretched
	// arrival gaps. 0 means DefaultMaxInFlightSessions.
	MaxInFlightSessions int
	// InjectionDuration bounds how long Run produces new sessions. Zero means
	// unbounded. In-flight sessions finish their drive scripts before Run
	// returns; external cancellation aborts them.
	InjectionDuration time.Duration
	// Ledger records session intents and op outcomes. Nil disables recording.
	Ledger SessionLedger
	// Meter instruments the driver. Required when Ledger is set so skipped
	// sessions stay visible; a noop meter is used when nil otherwise.
	Meter otelmetric.Meter
	// SessionDeadline is the verification deadline margin recorded per session:
	// the session's ledger deadline is its start time plus its last drive
	// offset plus this. 0 means DefaultSessionDeadline.
	SessionDeadline time.Duration
}

type Expectation struct {
	// TerminalStates are the allowed outcomes. A set rather than a single
	// state, to absorb legitimate races such as cancel vs. completion.
	TerminalStates []TerminalState
}

type FlowcoreEngine interface {
	RunWorkflow(ctx context.Context, namespaceID int64, idempotencyKey string, opts *flowcore.RunWorkflowOptions) (*flowcore.RunWorkflowResult, error)
	CancelWorkflow(ctx context.Context, workflowKey string) error
	SendToWorkflowChannel(ctx context.Context, idempotencyKey, channelToken string, value *pkg_autoflow.Value) error
}

type FlowcoreTarget struct {
	Engine      FlowcoreEngine
	NamespaceID int64
}

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

type ObserverConfig struct {
	Log    *slog.Logger
	Store  *ledger.Store
	Client WorkflowInfoClient
	// Meter instruments the observer. Optional; nil means no metrics.
	Meter otelmetric.Meter
	// Interval is the pause between ticks. 0 means DefaultObserveInterval.
	Interval time.Duration
	// BatchSize caps sessions resolved per tick. 0 means DefaultObserveBatchSize.
	BatchSize int
	// MinAge excludes sessions younger than this. 0 means DefaultObserveMinAge.
	MinAge time.Duration
	// MaxAge excludes sessions older than this. 0 means DefaultObserveMaxAge.
	MaxAge time.Duration
}

type RateModel struct {
	Min    int
	Max    int
	Period time.Duration
	Seed   uint64
}

type SendOp struct {
	Channel string
	Payload proto.Message
}

type SessionHandle interface {
	// WorkflowKey identifies the started workflow in its engine's format.
	WorkflowKey() string
	Send(ctx context.Context, idempotencyKey string, op *SendOp) error
	Cancel(ctx context.Context) error
}

type SessionLedger interface {
	SessionStarted(ctx context.Context, rec *ledger.SessionRecord) error
	WorkflowKeyKnown(sessionID uuid.UUID, key string)
	OpDone(sessionID uuid.UUID, opIndex int32, err error)
}

type Source interface {
	Name() string
	// NextUnit returns the next Unit. All randomness must come from rng so a
	// run is reproducible from its seed.
	NextUnit(rng *rand.Rand) (*Unit, error)
}

type StartSpec struct {
	AutoFlow *AutoFlowStart
	Autocore *AutocoreStart
}

type Target interface {
	Start(ctx context.Context, idempotencyKey string, start StartSpec) (SessionHandle, error)
}

type TerminalState int

type Unit struct {
	Name        string
	Description string
	Start       StartSpec
	// Drive holds the timed external operations performed against the
	// running workflow, ordered by offset.
	Drive  []DriveOp
	Expect Expectation
}

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

type WeightedSource struct {
	Source Source
	Weight int
}

type WorkflowInfoClient interface {
	GetWorkflowInfo(ctx context.Context, key autocore.WorkflowKey) (*autocore.WorkflowInfo, error)
}