studio

type CardScreener interface {
	Screen(ctx context.Context, cfg config.Reader, fs afero.Fs, dir string) ([]takescmd.SelectedScreen, error)
}

type CertSource interface {
	ServerCert(ctx context.Context, host string, ips []net.IP) (*tls.Certificate, error)
}

type Chatter interface {
	Propose(ctx context.Context, system, user string, onToken func(string)) (reel.Storyboard, string, error)
}

type ClientFactory func(ctx context.Context, systemPrompt string) (gochat.ChatClient, error)

type CommitStatus struct {
	Committed bool   `json:"committed"        yaml:"committed"`
	Hash      string `json:"hash,omitempty"   yaml:"hash,omitempty"`
	Reason    string `json:"reason,omitempty" yaml:"reason,omitempty"`
}

type ConnectionChecker interface {
	Check(ctx context.Context, cfg, accounts *config.Store) ([]refresh.Status, error)
}

type Cost = spend.Cost

type Deps struct {
	Log logger.Logger
	// FS is the project filesystem; ReelRoot is the active reel-workspace root
	// resolved from config (reelcmd.Root) — the studio API reuses internal/workspace
	// over these, the same core the CLI uses (spec 0011 §5).
	FS       afero.Fs
	ReelRoot string
	// ProjectDir is the startup project directory (the cwd); RegistryPath is the
	// user-scoped studio.yaml. Both drive the project switcher (spec 0011 §2.2);
	// empty values disable persistence/switching (e.g. in unit tests).
	ProjectDir   string
	RegistryPath string
	// OutcomesPath is the user-scoped outcomes.yaml, beside studio.yaml — the last
	// git outcome per workspace, so "why is this reel not pushed?" survives the
	// request and a restart (spec 0052 D6). Empty disables the record.
	OutcomesPath string
	// Config backs theme/palette resolution for storyboard validation (nil → the
	// structural rules only, palette-role checks skipped — like `storyboard draft`).
	Config *config.Store
	// Accounts is the user-scoped credentials store (~/.keryx/accounts.yaml). The
	// publish path rotates tokens — TikTok on every post — and without a separate
	// destination those writes route to the highest-precedence writable layer,
	// which inside a project is the committable .keryx.yaml (spec 0042 §3.4).
	// nil → credentials resolve from Config, the pre-split behaviour.
	Accounts *config.Store
	// UserThemes is the user theme library (~/.keryx/themes.yaml), the destination
	// for promoting a project theme. nil → the studio reports promotion
	// unavailable rather than silently doing nothing.
	UserThemes *config.Store
	// ConfigDir is the user config directory (~/.keryx), used to resolve the theme
	// library for the no-project fallback catalog.
	ConfigDir string
	// Chat proposes storyboard revisions for the chat endpoint (nil → the endpoint
	// reports no provider configured). Injectable so the endpoint tests with a fake.
	Chat Chatter
	// Summarise drafts the reel's source brief from the linked post (0029 §9
	// note 29; nil → the endpoint reports no provider configured). Injectable so
	// the endpoint tests with a fake — no LLM spend.
	Summarise Summarizer
	// Compose drafts per-platform social copy for the AI-compose endpoint (R-SOC-4;
	// nil → the endpoint reports no provider configured). Injectable so the endpoint
	// tests with a fake — no LLM spend.
	Compose SocialComposer
	// Post runs the approved-gated post-now fan-out (R-UI-27, the irreversible
	// action; nil → the endpoint reports posting unavailable). Injectable so tests
	// fake it — no real network posting in CI.
	Post Poster
	// Git performs commit-on-save, push, and clone (R-GIT-2/3); nil → a no-op.
	// Injectable so studio tests don't need a real repo.
	Git GitOps
	// Gen produces card/cover/portrait media (R-UI-29/3; spec 0013); nil → a no-op
	// that reports generation unavailable. Injectable so studio tests fake it (no
	// provider, no spend, no network).
	Gen Generator
	// Render renders the workspace to an mp4 (R-UI-8/11; spec 0017); nil → a no-op
	// that reports rendering unavailable. Local-only (shells out to ffmpeg).
	// Injectable so studio tests fake it (no ffmpeg, no exec).
	Render Renderer
	// Screen runs the contact sheet's on-demand text-leak screen of the selected
	// card illustrations (R-GEN-26 surfaced in S2); nil → the "screen now" endpoint
	// reports screening unavailable. Injectable so studio tests fake it (no vision
	// provider, no spend). The cached-verdict GET path needs no seam — it is a pure
	// ledger read.
	Screen CardScreener
	// Quota reports the voice account's character quota for the quota widget (spec
	// 0016); nil → the endpoint reports quota unavailable. Injectable so studio tests
	// fake it (no provider, no network).
	Quota QuotaReporter
	// ConnCheck live-probes platform token health for the Connections "check now"
	// action (S5); nil → the endpoint reports the check unavailable. Injectable so
	// studio tests fake it (no network, no token access).
	ConnCheck ConnectionChecker
	// Storage resolves the configured object store for the Commit & push media
	// sync (spec 0039); nil → the package registry (objectstore.Default.Resolve).
	// Injectable so studio tests fake the store — no bucket, no network.
	Storage StorageResolver
	// CertSource yields the studio's TLS certificate on a non-loopback bind (spec
	// 0027, R-TLS-1/3). Non-nil → the studio serves HTTPS and sets a Secure session
	// cookie; nil → the exposure gate falls back to http (a documented downgrade, kept
	// for tests). The command wires a trusted local-CA source with a self-signed
	// fallback, so a real exposed bind is always HTTPS.
	CertSource CertSource
	// Analyzer runs first-use avatar analysis (spec 0034 D3) — nil resolves the
	// configured image provider at request time. Injectable so tests fake the vision.
	Analyzer avatar.Describer
	// NoAuth disables the exposure token gate on a non-loopback bind (the `--no-auth`
	// flag). The studio still serves HTTPS, but anyone who can reach the address has
	// full access — a deliberate, logged opt-out for trusted-network dev/testing.
	NoAuth bool
}

type Generator interface {
	// Available reports whether generation can proceed (an image provider is
	// configured); a non-nil error is the actionable reason for a 503. It does not
	// guarantee a working API key — a missing key surfaces as a failed job with the
	// provider's own message.
	Available() error
	// Generate writes the request's candidate takes into its slot on fs (the active
	// worktree, possibly an in-memory remote), resolving the provider + theme against
	// cfg (the active project's config), and returns the written take paths.
	Generate(ctx context.Context, cfg *config.Store, fs afero.Fs, req gencmd.Request) ([]string, error)
}

type GitOps interface {
	Commit(ctx context.Context, projectDir, relPath, msg string) CommitStatus
	Push(ctx context.Context, projectDir string) PushStatus
	Clone(ctx context.Context, remote, branch, targetDir string) error
	// OpenInMemory clones a remote into RAM and returns the held repo (the
	// in-memory backend). The caller holds it for the active project's session.
	OpenInMemory(ctx context.Context, remote, branch string) (MemRepo, error)
	// DirtySlugs reports which workspaces under reelRootRel (project-relative)
	// carry uncommitted changes — the rail's "remember to commit" indicator.
	// Best-effort: any failure (not a repo, status error) returns nil.
	DirtySlugs(ctx context.Context, projectDir, reelRootRel string) map[string]bool
}

type GitOutcome struct {
	At     time.Time     `json:"at"               yaml:"at"`
	Commit *CommitStatus `json:"commit,omitempty" yaml:"commit,omitempty"`
	Push   *PushStatus   `json:"push,omitempty"   yaml:"push,omitempty"`
}

type Job struct {
	ID        string   `json:"id"`
	Kind      string   `json:"kind"`
	Card      int      `json:"card,omitempty"`
	State     JobState `json:"state"`
	Takes     []string `json:"takes,omitempty"`
	Results   []string `json:"results,omitempty"` // post jobs: per-platform result lines
	Output    string   `json:"output,omitempty"`  // render jobs: the produced mp4 (workspace-relative)
	Cost      Cost     `json:"cost"`
	Error     string   `json:"error,omitempty"`
	ElapsedMS int64    `json:"elapsed_ms"`
	EtaMS     int64    `json:"eta_ms"`
	Percent   float64  `json:"percent,omitempty"` // render jobs: live 0..100 when the backend streams it
	// contains filtered or unexported fields
}

type JobState string

type MediaPullStatus struct {
	mediastore.PullReport
	Skipped string `json:"skipped,omitempty"`
	Error   string `json:"error,omitempty"`
}

type MediaPushStatus struct {
	mediastore.Report
	// Skipped names why no sync was attempted (unconfigured storage, no active
	// project) — an expected state, not a fault.
	Skipped string `json:"skipped,omitempty"`
	// Error is a real sync failure. The git commit still proceeds — media.lock
	// simply stays at its last-pushed pins.
	Error string `json:"error,omitempty"`
}

type MemRepo interface {
	WorkFS() afero.Fs
	Commit(ctx context.Context, relPath, msg string) CommitStatus
	Push(ctx context.Context) PushStatus
	// DirtySlugs mirrors GitOps.DirtySlugs over the held worktree.
	DirtySlugs(reelRootRel string) map[string]bool
}

type Options struct {
	Host string
	Port int
}

type Poster interface {
	Post(ctx context.Context, fs afero.Fs, stores publish.Stores, root, slug string, platforms []string) ([]postcmd.Result, error)
}

type PushStatus struct {
	Pushed bool   `json:"pushed"           yaml:"pushed"`
	Reason string `json:"reason,omitempty" yaml:"reason,omitempty"`
}

type QuotaReporter interface {
	Quota(ctx context.Context, cfg config.Reader) (provider.Quota, error)
}

type RenderOpts struct {
	Silent bool
	Theme  string
	Out    string // absolute output mp4 path
	// OnProgress (optional) receives live render progress — set by the job runner to
	// feed the job's percent; nil for a plain render (spec 0026).
	OnProgress func(provider.Progress)
}

type RenderResult struct {
	VideoPath   string
	DurationSec float64
	Cards       int
}

type Renderer interface {
	// Available reports whether rendering can proceed (a renderer is resolvable).
	Available() error
	// Render renders the workspace at dir (a path in fs) to opts.Out, resolving the
	// renderer + theme against cfg. fs is the active project's filesystem (on-disk or
	// in-memory), so render is no longer local-only.
	Render(ctx context.Context, fs afero.Fs, cfg *config.Store, dir string, opts RenderOpts) (RenderResult, error)
	// BedSeconds returns the music-bed length (seconds) the reel will request — the
	// VO-driven total (probing the promoted VO via the render backend), or the default
	// when no VO sizes it / the renderer is unavailable. Used to price music generation
	// per second. Never errors — it degrades to the default so the cost cue always works.
	BedSeconds(ctx context.Context, fs afero.Fs, cfg *config.Store, dir string) float64
	// Timeline returns the reel's VO-driven pre-build timing (R-UI-31): per-card
	// on-screen duration + start offset and the total, probing promoted VO through the
	// render backend (mirrors BedSeconds), or the storyboard-`dur` fallback when no VO
	// sizes it (Plan.VODriven == false). Read-only — it renders nothing.
	Timeline(ctx context.Context, fs afero.Fs, cfg *config.Store, dir, slug string, sb reel.Storyboard) (reelcmd.Plan, error)
}

type SelfSignedSource struct{}

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

type SocialComposer interface {
	Compose(ctx context.Context, fs afero.Fs, cfg config.Reader, wsDir, platform string, ground socialcmd.Grounding) (social.Set, error)
}

type StorageResolver func(config.Reader) (objectstore.Store, error)

type Summarizer interface {
	Summarise(ctx context.Context, system, user string) (string, error)
}