config

type Access struct {
	RedeemUrl string `yaml:"redeemUrl"`
}

type Auth struct {
	WalletPath string `yaml:"walletPath"`
	PasskeyEnv string `yaml:"passkeyEnv"`
}

type Config struct {
	// DataDir is the ROOT directory (default ~/.any). Each account
	// lives in <dataDir>/<accountId>/ (wallet.key, sdk/, index/,
	// server.pid); a wallet.key directly at the root is the legacy
	// flat layout and acts as the default account, keeping its data at
	// the root. config.yaml and the shared models/ cache stay at the
	// root.
	DataDir string `yaml:"dataDir"`
	// Mode declares who owns this server: "standalone" (default — the
	// user; keys on disk, account resolved from disk) or "managed" (a
	// spawning host; account key supplied per boot, never on disk).
	// See mode.go.
	Mode string `yaml:"mode"`
	// Account selects which account to boot when the root holds more
	// than one. Empty = the default (root wallet.key, or the sole
	// per-account dir). Standalone only.
	Account string        `yaml:"account"`
	Listen  Listen        `yaml:"listen"`
	Auth    Auth          `yaml:"auth"`
	Network Network       `yaml:"network"`
	Storage Storage       `yaml:"storage"`
	Sync    Sync          `yaml:"sync"`
	P2P     P2P           `yaml:"p2p"`
	Index   Index         `yaml:"index"`
	Files   Files         `yaml:"files"`
	Push    Push          `yaml:"push"`
	Local   Local         `yaml:"local"`
	Access  Access        `yaml:"access"`
	WebUI   WebUI         `yaml:"webUI"`
	Log     logger.Config `yaml:"log"`
}

type Files struct {
	// PublicReadBaseUrl overrides the network-advertised public read
	// base for durable file downloads ({base}/blob/{spaceId}/{rootCid}).
	// Normally left empty — the SDK resolves it once from the network's
	// fileV2 nodes and caches it. Set it for private deployments that
	// front the object store themselves.
	PublicReadBaseUrl string `yaml:"publicReadBaseUrl"`
	// GCInterval enables the SDK's periodic file-cache safety sweep at
	// the given cadence (duration string, e.g. "1h"). Empty/zero — the
	// default — means NO automatic sweep: reclamation is caller-driven
	// via POST /v1/files/cache/{free,sweep} and per-file offload.
	GCInterval string `yaml:"gcInterval"`
}

type Flags struct {
	ConfigPath string
	DataDir    string
	Mode       string
	Account    string
	Addr       string
	WalletPath string
	LogLevel   string
}

type GlobalP2P struct {
	// Enabled is an opt-out on the production network, where the
	// defaults supply relays, and an opt-in anywhere else: absent
	// resolves to on only once relayUrls are known. False always wins.
	Enabled *bool `yaml:"enabled"`
	// RelayUrls are the home-relay candidates. The device probes them
	// and keeps a session to the nearest; a relay forwards encrypted
	// QUIC and helps the two sides find a direct path.
	RelayUrls []string `yaml:"relayUrls"`
	// PkarrRelayUrls hold the account's device-discovery record — how
	// this account's own devices find each other, and how a device
	// holding only the mnemonic finds them. Empty leaves the account
	// layer off; devices then know each other only through the records
	// of the spaces they share.
	PkarrRelayUrls []string `yaml:"pkarrRelayUrls"`
	// InsecureRelay admits http:// relay URLs — plaintext to the relay,
	// for a self-hosted or local relay without a certificate. The
	// end-to-end encryption between the two devices is unaffected;
	// what leaks is which endpoints are talking. Development only.
	InsecureRelay bool `yaml:"insecureRelay"`
	// InsecurePkarr admits http:// pkarr relay URLs. Development only.
	InsecurePkarr bool `yaml:"insecurePkarr"`

	// Port fixes the UDP port of the iroh endpoint. 0 = ephemeral.
	Port int `yaml:"port"`
	// MaxConnections caps the global connections this device keeps
	// open, chosen to cover the loaded spaces. 0 = the SDK default (4).
	MaxConnections int `yaml:"maxConnections"`
	// MaxInbound is the headroom above MaxConnections for connections
	// other devices opened. 0 = the SDK default (8).
	MaxInbound int `yaml:"maxInbound"`
	// contains filtered or unexported fields
}

type Index struct {
	// Enabled gates the whole indexer. Default true.
	Enabled bool `yaml:"enabled"`
	// Embedder selects the embedding provider: "auto" (DEFAULT — the
	// online openai primary when index.openai.apiKey is set, with the
	// local model as fallback, both the SAME model; local only when no
	// key is configured), "local" (in-process llama.cpp only), "ollama",
	// "openai" (any OpenAI-compatible /embeddings API), or "none"
	// (FTS-only). Empty resolves to the default.
	Embedder string `yaml:"embedder"`
	// EmbedBatch / EmbedConcurrency tune the embed loop. EmbedBatch is
	// docs per EmbedDocs call (0 = default 64). EmbedConcurrency is how
	// many batches embed in parallel (0 = default: 1 for local, a few for
	// online openai/auto — parallel requests are the online throughput
	// win; the local child serves one frame at a time so concurrency is
	// safe but pointless). See docs/13-index.md.
	EmbedBatch       int         `yaml:"embedBatch"`
	EmbedConcurrency int         `yaml:"embedConcurrency"`
	Ollama           IndexOllama `yaml:"ollama"`
	OpenAI           IndexOpenAI `yaml:"openai"`
	Local            IndexLocal  `yaml:"local"`
	Vector           IndexVector `yaml:"vector"`
	Search           IndexSearch `yaml:"search"`
}

type IndexLocal struct {
	// ModelPath points at an existing GGUF file; when set, no download
	// is attempted (air-gapped operation).
	ModelPath string `yaml:"modelPath"`
	// ModelUrl overrides the download source for the default model path.
	ModelUrl string `yaml:"modelUrl"`
	// ModelSha256 is the expected checksum of the downloaded model.
	// Empty with a custom ModelUrl skips verification (logged once).
	ModelSha256 string `yaml:"modelSha256"`
	// LibDir holds the llama.cpp shared libraries; default is the
	// `llamacpp` directory next to the executable.
	LibDir string `yaml:"libDir"`
	// ContextSize bounds embedding input in tokens — longer texts are
	// truncated (docs/13-index.md § Known limits). Default 2048.
	ContextSize int `yaml:"contextSize"`
	// QueryPrefix is prepended to query (not document) texts. Empty
	// means: the default model's retrieval instruction for the default
	// model, nothing for a custom ModelPath/ModelUrl.
	QueryPrefix string `yaml:"queryPrefix"`
	// Dim truncates output vectors (Matryoshka) and renormalizes;
	// 0 keeps the model's full dimension (1024 for the default model).
	Dim int `yaml:"dim"`
	// Threads sets the llama.cpp compute thread count (NThreads /
	// NThreadsBatch) — the CPU budget the embedder child decodes with.
	// 0 = default to runtime.NumCPU()-1 (leave one core free). Going
	// beyond the physical core count can regress on hyperthreaded CPUs;
	// lowering it is how you keep background indexing off the user's
	// cores. Changeable at runtime (Indexer.SetEmbedThreads) — it takes
	// effect on the child's next spawn.
	Threads int `yaml:"threads"`
	// Niceness lowers the embedder child's scheduling priority so a
	// re-index yields to interactive work: 0..19 on Unix (nice), a
	// below-normal/idle priority class on Windows. Absent = 10; 0 keeps
	// the server's own priority. Raising priority is not supported.
	Niceness *int `yaml:"niceness"`
	// RequestTimeout bounds one frame to the child process — one decode
	// group of up to BatchDocs texts (Go duration string). Default 3m.
	// It exists to unwedge a hung GPU: a lost device stops answering
	// rather than failing, so without a bound the embed loop blocks
	// forever. Generous by design — it polices a wedge, not slow
	// hardware.
	RequestTimeout string `yaml:"requestTimeout"`
	// GpuLayers overrides llama.cpp's n_gpu_layers. Absent keeps the
	// llama.cpp default: offload every layer when a usable GPU backend
	// is present, CPU otherwise. 0 forces CPU-only inference even with
	// GPU libs installed — the opt-out for machines where the embedder
	// shouldn't take VRAM (docs/13-index.md § GPU offload).
	GpuLayers *int `yaml:"gpuLayers"`
	// BatchDocs caps how many documents pack into one llama_decode as
	// parallel sequences. The unified KV cache partitions ContextSize
	// across them, so N caps each text at ContextSize/N tokens — a wider
	// batch trades input length for a per-decode saving that measures as
	// nothing on a realistic record mix (docs/13-index.md). 0 = default
	// 1 (one doc per decode, the whole ContextSize available to it).
	BatchDocs int `yaml:"batchDocs"`
}

type IndexOllama struct {
	Url   string `yaml:"url"`   // default http://localhost:11434
	Model string `yaml:"model"` // default embeddinggemma
}

type IndexOpenAI struct {
	BaseUrl string `yaml:"baseUrl"` // no default; required for "openai", and for "auto" once apiKey is set
	Model   string `yaml:"model"`
	ApiKey  string `yaml:"apiKey"` // never logged
}

type IndexSearch struct {
	// FtsWeight / VectorWeight scale each leg's reciprocal-rank-fusion
	// contribution in hybrid mode. Default 1 each (plain RRF). Lowering
	// VectorWeight trusts the lexical leg more — useful while the dense
	// leg is noisy (short chunks, weak embedder).
	FtsWeight    float64 `yaml:"ftsWeight"`
	VectorWeight float64 `yaml:"vectorWeight"`
	// AdaptiveWeights down-weights the FTS leg per query by its score
	// concentration — so a weak lexical leg (e.g. paraphrastic queries
	// where BM25 is flat) can't drag hybrid below the dense leg. Off by
	// default. docs/search/README.md § per-corpus leg weighting.
	AdaptiveWeights bool `yaml:"adaptiveWeights"`
	// DefaultOperator controls how bare FTS terms combine: "or" (default,
	// any term) or "and" (all terms — higher precision, lower recall).
	DefaultOperator string `yaml:"defaultOperator"`
	// MinVectorSim drops vector hits below this cosine similarity before
	// fusion. Default 0 keeps the legacy floor (similarity must be > 0).
	// NOTE: measured against the default local model (Qwen3-Embedding-0.6B)
	// a static floor is a poor noise filter — gibberish queries score
	// ~0.6 cosine, on par with on-topic, so any cutoff that drops noise
	// also drops real hits (internal/indexer/live_probe_test.go). Leave
	// at 0 for that model; raise only for a better-calibrated embedder.
	MinVectorSim float64 `yaml:"minVectorSim"`
	// StopWords toggles query-side stop-word stripping for the FTS leg
	// only (the vector leg always sees the full query). nil/absent = on
	// (a precision win on a bag-of-words OR engine); set false to keep
	// the raw query.
	StopWords *bool `yaml:"stopWords"`
	// Bm25B / Bm25K1 tune the FTS index's BM25 (any-store FulltextParams).
	// 0 = the engine default (b=0.75, k1=1.2). Lower b reduces the bias
	// toward short docs (e.g. 0.4 for mixed-length notes). Set at index
	// creation — changing them needs a rebuild.
	Bm25B  float64 `yaml:"bm25B"`
	Bm25K1 float64 `yaml:"bm25K1"`
	// TitleWeight is the BM25F boost for the per-doc `title` field over
	// `body` (editor heading / program method signature / memory context).
	// 0 = no boost AND no title field in the index: the field set is
	// decided when the index is created, so going 0 → non-zero needs a
	// rebuild (remove <data-dir>/index). Changing between non-zero values
	// is read at query time and takes effect immediately.
	TitleWeight float64 `yaml:"titleWeight"`
	// QueryEmbedTimeout bounds the query embedding of one /search (Go
	// duration string). Past it hybrid answers lexical-only
	// (vectorStatus=unavailable) and mode=vector fails as
	// index.embedder_unavailable, so a cold model load, a wedged child or
	// a slow remote API degrades a search instead of holding it. Default
	// 5s; raise it for a remote embedder that is legitimately slower.
	QueryEmbedTimeout string `yaml:"queryEmbedTimeout"`
}

type IndexVector struct {
	// Dim is the embedding dimension; 0 = learn it from the first
	// successful embed batch.
	Dim int `yaml:"dim"`
	// Mode selects the ANN index strategy: "" / "ivfsq" (default —
	// cheap near-flat ingest + physical deletes, ~3–4 recall@10 below
	// exact), "btree" / "hnsw" (recall ≈ exact but serial super-linear
	// ingest + tombstone-rebuild deletes), "hybrid" (HNSW + RAM cache),
	// or "bruteforce" (exact, O(N) per query). docs/search/README.md
	// § index mode.
	Mode string `yaml:"mode"`
}

type Listen struct {
	Addr string `yaml:"addr"`
}

type Local struct {
	// Enabled gates the /v1/local routes. Default true. When false the
	// routes answer 409 local.disabled and no collection is created;
	// the file is the SDK's and stays open, so existing local
	// collections sit untouched on disk.
	Enabled bool `yaml:"enabled"`
}

type Network struct {
	NodeconfPath string `yaml:"nodeconfPath"`
	Nodeconf     string `yaml:"nodeconf"`
}

type P2P struct {
	// Enabled is the LAN layer's opt-out: absent/null = on. An explicit
	// false also suppresses Global's PACKAGED default (see
	// GlobalP2P.isEnabled), so turning peer-to-peer off with one line
	// stays one line; relays named by hand are kept.
	Enabled *bool `yaml:"enabled"`
	// Port fixes the QUIC listen port. 0 (default) = reuse the port
	// persisted from the previous run, or pick an ephemeral one.
	Port int `yaml:"port"`
	// ServiceName overrides the mDNS service type (default "_any._tcp").
	// Set it to isolate a deployment onto its own discovery namespace.
	ServiceName string `yaml:"serviceName"`
	// LocalDiscovery switches mDNS announce and browse alone; the QUIC
	// listener stays up. Absent/null resolves per platform and mode
	// (LocalDiscoveryEnabled): off for a managed server on macOS, on
	// everywhere else. Flipped at runtime through PUT /v1/local-discovery.
	LocalDiscovery *bool `yaml:"localDiscovery"`
	// Global is the internet-wide layer, independent of the LAN one.
	Global GlobalP2P `yaml:"global"`
}

type Push struct {
	// Enabled is a tristate: nil (the default) means enabled only when
	// PeerId is set — configuring a push node is the opt-in. Explicit
	// false disables push even with a PeerId present; explicit true
	// without peer info still cannot run (Active() stays false).
	Enabled *bool `yaml:"enabled"`
	// PeerId is the push node's peer id (its device key identity).
	PeerId string `yaml:"peerId"`
	// Addrs are the node's dial addresses (same forms the nodeconf
	// uses, e.g. "quic://host:port" or "host:port").
	Addrs []string `yaml:"addrs"`
}

type Storage struct {
	Topology string `yaml:"topology"`
}

type Sync struct {
	DialTimeout     string `yaml:"dialTimeout"`
	ChangeBatchSize int    `yaml:"changeBatchSize"`
}

type WebUI struct {
	Enabled bool `yaml:"enabled"`
}