botapi

type Event struct {
	Type       string // "data" | "notice"
	Channel    string
	Symbol     string
	Origin     string
	ServerTime int64
	Source     string
	// AccountSeq is the sub-account of a private-channel data event (surfaced as
	// ev.accountSeq), nil when not applicable/untagged (public channels, notices,
	// or a frame the server did not tag with an accountSeq).
	AccountSeq *int
	Payload    []byte
}

type Options struct {
	// Where is the per-data-event predicate expression (optional).
	Where string
	// On is the per-event handler body, run after Where passes and for every
	// notice (optional). May use await; korbit.*/db.* are available.
	On string
	// Init is a script run once before streaming (optional). May use await;
	// korbit.*/db.* are available. No time budget — only SignalCtx bounds it.
	Init string

	// API is the L2 operations layer behind every korbit.* method — it owns the
	// retry/idempotency policy and the place/history/candles/funding protocols.
	// nil makes korbit.* unavailable. The bindings carry NO call policy of their
	// own: they parse+validate, then call API.{PlaceOrder,History,Candles,
	// FundingHistory,Invoke}. The order-row journal seam, the clock-resync hook,
	// the reconcile Sleep, and the per-call retry budget all live on the API.
	API *ops.API
	// Surface is the frontend identity for the operations ledger (e.g. "monitor",
	// "mcp"), threaded into every operation's RunInput.
	Surface string
	// KeyName / APIKeyID identify the signing key for the operations ledger (the
	// public api-key id; never a secret). "" for a public-only session.
	KeyName  string
	APIKeyID string
	// KeyManager provides per-key metadata lookups (MetaDefaultAccountSeq) so
	// the bot's accountSeq resolution honors a stored key's configured default.
	// It is ignored when KeyName is empty or when Inline is set (an inline
	// environment credential has no stored per-key metadata).
	KeyManager *keys.Manager
	// Inline is true when the signing credential came from inline environment
	// material rather than a stored key (mirrors keys.Selection.Inline), so the
	// per-key metadata lookup is skipped.
	Inline bool
	// CredsErr, when non-empty, is the message authenticated methods throw —
	// set when no signing key could be resolved.
	CredsErr string

	// DBPath is the SQLite file behind db.*, opened lazily on first use.
	// Empty makes db.* unavailable.
	DBPath string
	// NoFsync opens the db.* database with PRAGMA synchronous=OFF (faster writes,
	// weaker crash-durability) — the --no-fsync/KORBIT_CLI_NO_FSYNC opt-in.
	NoFsync bool

	// Stateful builds a materialized state.Store fed by Ingest and exposes it as
	// the synchronous state.* global. When false the Store is never built or fed
	// (zero cost) and every state.* method throws.
	Stateful bool

	// AccountSeqs is the set of private sub-accounts the session subscribed
	// (effAccountSeq-normalized, ≥1), used to roll the store's PER-ACCOUNT
	// readiness up into the single state.ready().balances / .openOrders booleans:
	// ready is true only when EVERY subscribed account is ready, so a partial
	// snapshot (one account healed, another still failing its backfill) never
	// reads as complete. Empty when no private channels are subscribed, which
	// keeps those flags false (as they were when balances/orders never latched).
	AccountSeqs []int

	// MaxConcurrency caps in-flight korbit.*/db.* work (default 8).
	MaxConcurrency int

	// ServerNow is the session's server-clock estimate, behind korbit.now() (a bot
	// reads it to compare against server-stamped timestamps). It is NOT used for any
	// local record — see Now.
	ServerNow func() int64
	// Now is the local system clock (unix ms), used only to stamp the materialized
	// state Store's Health.LastDataAt — a local receive time, compared against the
	// reader's own "now", so it stays in the system frame (never the server-clock
	// estimate). nil = time.Now().UnixMilli().
	Now func() int64
	// Sleep delays db.* retries and is injectable for tests (default time.Sleep).
	// The korbit.* reconcile sleeps use ops.API.Sleep instead.
	Sleep func(time.Duration)
	// Stderr receives console output and runtime warnings (default: discard).
	Stderr io.Writer
	// Log is the optional operational logger passed to the materialized state
	// Store (state reconcile mechanics, Debug). nil = silent. Only used when
	// Stateful is set.
	Log *slog.Logger
	// SignalCtx, when set, interrupts running JavaScript on cancellation
	// (Ctrl-C/SIGTERM) — the only bound on --init and on a runaway script.
	SignalCtx context.Context
}

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