server

type Builtin struct {
	ID   string
	Path string
}

type ConfigInfo struct {
	IndexDefaults    indexOptions `json:"indexDefaults"`
	IndexConcurrency int          `json:"indexConcurrency"`
	Roots            []Root       `json:"roots"`
	LibDir           string       `json:"libDir"`
	Prepared         int          `json:"prepared"`
	UseCached        bool         `json:"useCached"`
	ConfigPath       string       `json:"configPath"`
	Total            int          `json:"total"`
	// HowtoRemoved: the user removed the built-in wudict howto; the setup
	// page offers it back.
	HowtoRemoved bool `json:"howtoRemoved,omitempty"`

	// DictDirOrigin is "flag", "env", "file" or "default"; DictDirEditable is
	// false when a flag or environment variable outranks the config file, so
	// the UI can say that saving here will not take effect rather than
	// silently doing nothing on the next launch.
	DictDirOrigin   string `json:"dictDirOrigin"`
	DictDirEditable bool   `json:"dictDirEditable"`

	// ConfigProblems are lines of wudict.toml that set nothing - a typo'd key
	// is otherwise silent - as config.Config.Problems words them.
	ConfigProblems []string `json:"configProblems,omitempty"`

	// Effective is what every tunable config key currently resolves to, and
	// which layer supplied it (config.Tunables). A platform shell overrides
	// these for the device it runs on by writing the flag or environment layer
	// (D101); it reads them back here because several of the defaults are
	// computed from the device itself and Go is the only place that knows the
	// formula (internal/config/tuning.go).
	Effective map[string]config.Setting `json:"effective,omitempty"`

	// RevealLabel is the platform's own name for "show this in the file
	// manager" - the phrase a user of that OS already recognises.
	RevealLabel string `json:"revealLabel"`
	CanReveal   bool   `json:"canReveal"`

	// CanDelete says this caller may remove a dictionary (D63 amended). True
	// from the machine running wudict, whatever platform that is - the user at
	// the keyboard owns those files, and managing a library includes throwing
	// part of it away. From a remote browser it follows ALLOW_REMOTE_DELETE,
	// which defaults to OFF. It is not CanReveal's complement: that would
	// withhold the control from precisely the user who owns the files and hand
	// it to every browser on the LAN.
	CanDelete bool `json:"canDelete"`
	CanExit   bool `json:"canExit"`
	// SystemLogHasErrors tells the panel whether a retained System Log has an
	// error or crash record.
	SystemLogHasErrors bool `json:"systemLogHasErrors"`

	// PathAliases shorten the prefix that is identical on every row and
	// therefore carries no information: {prefix, label} pairs, first match
	// wins. On a desktop that is one entry, the home directory shown as "~"
	// (D48). DISPLAY ONLY: the clipboard and /api/reveal keep the absolute
	// path, which is what a user pasting into a script - or the file manager -
	// needs. A label is a NAME, not a path: "~" is one only where a shell
	// would accept it, which is why the platform decides (see pathAliases).
	PathAliases [][2]string `json:"pathAliases,omitempty"`
}

type DictPref struct {
	Groups []string `json:"groups,omitempty"` // user group IDs; independent of Off
	ID     string   `json:"id"`
	Path   string   `json:"path"`
	Name   string   `json:"name,omitempty"`   // display name, for a readable file
	Title  *string  `json:"title,omitempty"`  // optional user-facing label; nil restores the dictionary's own name
	Off    bool     `json:"off,omitempty"`    // excluded from "All dictionaries"
	Pinned *bool    `json:"pinned,omitempty"` // fixed at the top when All Dictionaries is sorted
}

type DictionaryGroup struct {
	ID             string       `json:"id"`
	Name           string       `json:"name"`
	Order          []groupOrder `json:"order,omitempty"` // member IDs and their pin state; independent of global order
	Filter         *groupFilter `json:"filter,omitempty"`
	SelectedFilter *groupFilter `json:"selectedFilter,omitempty"` // retained when the link is switched off
	// False sorts unpinned members alphabetically; true preserves manual order
	// and appends new members alphabetically. Nil is a legacy group whose mode
	// is inferred from its saved order before new members are merged.
	CustomOrder *bool `json:"customOrder,omitempty"`
}

type FirstRunMigration struct {
	Available bool `json:"available"`
	Forked    bool `json:"forked"`
}

type Option func(*Registry)

type Power int32

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

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

type ReindexStatus struct {
	Running bool `json:"running"`
	// Active dictionaries being processed now (bounded by logical processors).
	Active       int                      `json:"active"`
	ActiveDicts  []string                 `json:"activeDicts,omitempty"`
	BusyProgress []dictionaryWorkProgress `json:"busyProgress,omitempty"`
	// Done of Total dictionaries finished (failed ones included).
	Done  int `json:"done"`
	Total int `json:"total"`
	// Current is the dictionary being rebuilt, with its own entry progress.
	Current      string `json:"current,omitempty"`
	CurrentDone  int    `json:"currentDone,omitempty"`
	CurrentTotal int    `json:"currentTotal,omitempty"`
	// Failed names each dictionary that could not be rebuilt, with why.
	Failed []string `json:"failed,omitempty"`
	// Canceled: the user stopped the job; what finished stays finished.
	Canceled bool `json:"canceled,omitempty"`
}

type Root struct {
	Path   string `json:"path"`
	Count  int    `json:"count"` // dictionaries this folder was the first to offer
	Total  int    `json:"total"` // everything it holds (Total > Count ⇒ overlap)
	Exists bool   `json:"exists"`
}

type Runtime struct {
	Server   *Server
	Registry *Registry
	User     UserDir
}

type SearchError struct {
	Kind    SearchErrorKind
	Message string
}

type SearchErrorKind string

type SearchEvent struct {
	T       string        `json:"t"`
	Slots   []SearchSlot  `json:"slots,omitempty"`
	I       int           `json:"i"`
	Dict    string        `json:"dict,omitempty"`
	Name    string        `json:"name,omitempty"`
	Results []dict.Result `json:"results,omitempty"`
	Skipped bool          `json:"skipped,omitempty"`
	Error   string        `json:"error,omitempty"`

	// Rung says which reading of a full-text query this dictionary answered:
	// "phrase" (the words adjacent, in order), "near" (within the configured
	// window, ten tokens by default, any order) or "words" (anywhere in the
	// article). Absent in every other mode.
	//
	// It is reported because the relaxation is silent otherwise, and a search
	// tool that quietly answers a weaker question than the one asked is lying
	// about its result. The UI says so only when the answer is NOT the phrase -
	// the precise reading needs no announcement (D102).
	Rung string `json:"rung,omitempty"`
	// OneReading says the dictionary has a single reading and never tried
	// another, so Rung is not a relaxation and must not be announced as one
	// (an archive answering from its own index - see search.Hit.OneReading).
	OneReading bool `json:"oneReading,omitempty"`

	// NeedsIndex says this dictionary would have to read article texts to
	// answer the reading, and declined to (search.Hit.NeedsIndex). What the
	// reader gets instead is an offer to build our index for it: the same
	// reading, answered from positions.
	NeedsIndex bool   `json:"needsIndex,omitempty"`
	Term       string `json:"term,omitempty"`
	CacheID    string `json:"cacheID,omitempty"`
	Total      int    `json:"total,omitempty"`
	Complete   bool   `json:"complete,omitempty"`
	Start      int    `json:"start,omitempty"`
	HasNext    bool   `json:"hasNext,omitempty"`

	// Legacy morphology event fields retained for decoding older streams.
	From string `json:"from,omitempty"`
	To   string `json:"to,omitempty"`
	Lang string `json:"lang,omitempty"`
}

type SearchRequest struct {
	Query                string `json:"q"`
	Mode                 string `json:"mode,omitempty"`
	Format               string `json:"format,omitempty"`
	Dictionary           string `json:"dict,omitempty"`
	Limit                int    `json:"n,omitempty"`
	Highlight            bool   `json:"hl,omitempty"`
	Suggestions          bool   `json:"suggest,omitempty"`
	IgnoreDiacritics     bool   `json:"ignoreDiacritics,omitempty"`
	Origin               string `json:"-"`
	CacheAction          string `json:"cacheAction,omitempty"`
	CacheID              string `json:"cacheID,omitempty"`
	ReturnCacheID        string `json:"returnCacheID,omitempty"`
	ReturnCacheStorage   string `json:"returnCacheStorage,omitempty"`
	CacheCount           int    `json:"cacheCount,omitempty"`
	CacheOrder           int    `json:"cacheOrder,omitempty"`
	Start                int    `json:"start,omitempty"`
	Size                 int    `json:"size,omitempty"`
	Rung                 string `json:"rung,omitempty"`
	PageCacheDiagnostics bool   `json:"pageCacheDiagnostics,omitempty"`
	SearchDiagnostics    bool   `json:"searchDiagnostics,omitempty"`
	Transport            string `json:"-"`
	// contains filtered or unexported fields
}

type SearchSlot struct {
	Dict string `json:"dict"`
	Name string `json:"name"`
}

type Server struct {

	// ConfigPath, when set, is where the first-run setup flow persists
	// DICT_DIR. In-memory state is updated regardless, so setup works
	// even when the folder came from a CLI flag or the file is read-only.
	ConfigPath string

	// User is the folder beside the wudict.toml in effect, holding what the
	// user owns besides it (userdir.go). Empty: none of it can be saved.
	User UserDir

	// Version identifies this build in the Server response header. A second
	// launch uses that header to recognise an already-running wudict on
	// the port - without it, "the port is busy" says nothing about WHO holds
	// it, and sending the user's browser to an unknown local service would be
	// worse than an error message.
	Version string

	// DesktopExit asks the owning desktop process to stop its HTTP server and
	// tray. Nil for Android, tests, and hosts without a desktop Exit action.
	DesktopExit func()

	// AutoIndex is retained for compatibility with the shared UI API; the
	// DictShelf host leaves it disabled and prepares indexes only on explicit action.
	AutoIndex bool

	// First-run Windows data migration is offered in the folder dialog after it
	// has loaded. The host supplies filesystem operations; other platforms leave
	// these callbacks nil.
	FirstRunMigrationStatus func() FirstRunMigration
	ApplyFirstRunMigration  func(string) error

	// DictDirOrigin / DictDirEditable describe where the dictionary folders
	// came from (config layering), so the UI can warn that a flag or an
	// environment variable will override anything saved to the file.
	DictDirOrigin   string
	DictDirEditable bool

	// ConfigProblems are the config file's lines that set nothing
	// (config.Config.Problems), shown in the folder dialog.
	ConfigProblems []string

	// Effective is every tunable key's resolved value and origin, published by
	// /api/config for shells that override them per device (D101).
	Effective map[string]config.Setting

	// Speexdec is the path to the external speexdec binary. It is used when
	// UseExternalSpeex is set, or as a fallback when the in-process decoder is
	// not compiled in (CGO_ENABLED=0) or fails on a given file.
	Speexdec string

	// UseExternalSpeex forces the external speexdec binary even when the
	// in-process (cgo) libspeex decoder is available (config SPEEX_BACKEND).
	UseExternalSpeex bool

	// BrowserExtensions optionally pins which extension origins may read the
	// client API cross-origin (config BROWSER_EXTENSIONS). Empty = any
	// chrome-extension:// or moz-extension:// origin, which is what Firefox
	// forces anyway: its moz-extension UUID is regenerated per install, so
	// there is no stable id to list. See cors.go (D69).
	BrowserExtensions []string

	// AllowRemoteDelete lets a browser on another machine delete a dictionary
	// (config ALLOW_REMOTE_DELETE). Loopback may regardless; this is only
	// about the remote caller. New() sets it false, matching the config
	// default, so a Server built directly in a test behaves like a real one.
	AllowRemoteDelete bool

	// Morph lemmatizes a word when a search finds nothing anywhere, so an
	// inflected form still reaches its entry (O3, config MORPH_CACHE). Nil -
	// which is what a Server built directly in a test has - is disabled, and
	// every call site goes through Cache.Enabled.
	Morph *morph.Cache

	// WebOrigins lists http(s) page origins allowed to read the same three
	// endpoints cross-origin (config WEB_ORIGINS). Empty - the default - means
	// none: a web page gets nothing here. A single "*" allows any origin. See
	// cors.go (D69).
	WebOrigins []string

	// TrustedHosts lists DNS names, beyond "localhost", that may appear in a
	// request's Host header (config TRUSTED_HOSTS). Empty - the default -
	// means none: every legitimate client addresses this server by IP, so the
	// only thing a name buys is DNS rebinding. See host.go. A single "*"
	// disables the check, for a reverse proxy whose name we cannot know.
	TrustedHosts []string

	// AuthToken, when set, is the capability token every route outside
	// authFree must present (auth.go). Empty means the server is open, which
	// is the right default for a loopback bind and the wrong one for any
	// other; the CLI resolves which case this is (config.AuthRequired).
	AuthToken string

	// LemmaDir is where /api/lemmas installs lemma files (config LEMMA_DIR) -
	// the same folder Morph indexes, which is what makes an install visible to
	// the next search without a restart.
	LemmaDir string

	// LemmaURL is the catalogue those installs come from (config LEMMA_URL).
	// It is server state and never a request parameter: a client-chosen URL
	// would turn this endpoint into a fetcher for whatever address the machine
	// running wudict can reach.
	LemmaURL string

	// ImportKeep (config IMPORT_KEEP) decides what becomes of the archive an
	// import came from: "ask" leaves the question to the page, "keep" and
	// "delete" answer it. A FAILED import always keeps it, whatever this
	// says - see intake.Manager.Confirm.
	ImportKeep string

	// ImportURLHosts (config IMPORT_URL_HOSTS) optionally restricts which
	// sites this server will fetch an archive from. Empty - the default - is
	// any site: the link came from the person using the app, who found the
	// dictionary somewhere no list was ever going to enumerate (D139). It
	// earns its keep on a wudict other people can reach, where the caller
	// and the owner are no longer the same person.
	//
	// ImportInsecure (IMPORT_INSECURE) is a different question and is NOT
	// opened by the above: it lifts the two refusals that protect the machine
	// this runs on - plain http, and an address on the local network. Both
	// are server state for the same reason LemmaURL is: policy a request
	// could widen is not policy.
	ImportURLHosts []string
	ImportInsecure bool
	// contains filtered or unexported fields
}

type UIPrefs struct {
	UpdateChannel          string `json:"updateChannel,omitempty"`          // release, prerelease or beta; Windows and Android default to beta
	UpdateNotificationsOff bool   `json:"updateNotificationsOff,omitempty"` // notifications are on unless disabled
	ResultCacheLimitGB     int    `json:"resultCacheLimitGB,omitempty"`
	ResultCacheNoLimit     bool   `json:"resultCacheNoLimit,omitempty"`
	// CountAllResultsInBackground controls the background pass that counts
	// every match after the initial results. A new profile and the first launch
	// of each app version enable it; an explicit later choice is saved here.
	CountAllResultsInBackground *bool `json:"countAllResultsInBackground,omitempty"`
	// SkipBackgroundResultCount is the legacy opt-out key. Keep reading it for
	// older state files; CountAllResultsInBackground takes precedence.
	SkipBackgroundResultCount bool   `json:"skipBackgroundResultCount,omitempty"`
	SearchReturnCache         string `json:"searchReturnCache,omitempty"`
	CombinedDictionaryLimit   int    `json:"combinedDictionaryLimit,omitempty"`
	// SearchThreads caps how many dictionaries a search touches at once: the
	// server fan-out, and the Wildcards list build the page drives itself. 0 is
	// automatic - the fan-out the app chose for the platform - and a positive
	// value is the reader overriding it to measure.
	SearchThreads int `json:"searchThreads,omitempty"`
	// NearWords is the "near" reading's window: how many words may stand between
	// the words of a query, for both a prepared dictionary and an archive. 0
	// means the reader never chose one, and ftsq.NearDefault applies. It is an
	// instruction to the search path (unlike HL off, which is UI state): the
	// server resolves it with ftsq.ResolveNear and hands it to internal/search,
	// and the page shows the same resolved number in the mode's hint.
	NearWords int `json:"nearWords,omitempty"`
	// Suggestion limits apply to headword suggestions in the main search field.
	SuggestionPerDictionary int  `json:"suggestionPerDictionary,omitempty"`
	SuggestionListLimit     int  `json:"suggestionListLimit,omitempty"`
	DictIconsOff            bool `json:"dictIconsOff,omitempty"`

	FontSize int `json:"fontSize,omitempty"` // article text, px; 0 = the default

	// FontWeight is the article text's weight, in CSS units. 0 is the zero
	// value AND the default (400), which is the same bargain as FontSize: a
	// half-written state.json gets the default rather than a wrong value.
	// Server state and not localStorage, for the reason the size is not - a
	// reader who needs 500 needs it on the phone that reaches this server too.
	FontWeight int `json:"fontWeight,omitempty"`

	FontFamily string `json:"fontFamily,omitempty"` // system, charis, gentium or quivira

	// HLOff turns OFF marking of full-text matches inside articles. It is
	// negating for the same reason DictPref.Off is: the default is on, and a
	// default that is the zero value is a default a hand-written or
	// half-written state.json cannot get wrong. An absent key is the feature
	// working, never the feature silently missing.
	//
	// It is remembered state for the UI, not an instruction to the server: the
	// search path never reads it. The SPA turns it into ?hl= on the request,
	// which is what keeps an API client that never saw this file from
	// inheriting a preference set in somebody's browser.
	HLOff bool `json:"hlOff,omitempty"`

	// Also fold [ex] zones when the Examples Hide layer is enabled.
	HideUnmarkedExamples *bool `json:"hideUnmarkedExamples,omitempty"`

	// ExampleBackgroundOff opts out of the default background tint on examples.
	ExampleBackgroundOff bool `json:"exampleBackgroundOff,omitempty"`
	FadeExampleText      bool `json:"fadeExampleText,omitempty"`

	// FastFirst expands whichever dictionary answers first, instead of the
	// first dictionary in the user's own order that has a result (D73, D142;
	// default flipped in D144).
	//
	// Spelled as the opt-OUT, the way HLOff is, because the default is now the
	// reader's own order: the list they arranged is the answer to "which of
	// these do I want", and a race winner is not that answer. So an absent key
	// is the default strategy, which is the rule both flags obey - a
	// half-written state.json must not be able to invent a setting the user
	// never made.
	//
	// Like HLOff it is remembered state for the UI and not an instruction to
	// the server: /api/search knows nothing about it, because which section a
	// reader unfolds is a property of the reader, not of the answer.
	FastFirst bool `json:"fastFirst,omitempty"`

	// OpenN is how many sections open by themselves under the reader's own
	// order: the first OpenN dictionaries in that order that have a result.
	// 0 (absent) and 1 are both the default, one; there is no upper limit,
	// because the reader may trade speed for it. OpenAll opens every one that
	// has a result. The page's menu sets these and FastFirst together, and
	// FastFirst, which opens a single section, wins if a hand edit sets both.
	// Remembered state for the UI, like FastFirst: the server never reads it.
	OpenN   int  `json:"openN,omitempty"`
	OpenAll bool `json:"openAll,omitempty"`

	// SpeakOff turns OFF the read-aloud button that appears over a text
	// selection in an article. Negated like HLOff: the feature is on unless
	// the person said otherwise. Which VOICE reads is not here - the voices
	// are whatever the device in front of them has installed, so that choice
	// stays in that browser's localStorage.
	SpeakOff bool `json:"speakOff,omitempty"`

	// GroupsOff lists the picker sections the person has hidden, by facet id:
	// "lang", "pair", or a groups.ini section lower-cased (internal/facet).
	// Negated for the same reason as the flags above: every section the
	// library supports is shown unless the person said otherwise, and a facet
	// added tomorrow appears without a migration. Ids are kept opaque here - the server never groups anything,
	// and an id no facet uses any more simply hides nothing.
	GroupsOff []string `json:"groupsOff,omitempty"`

	// False sorts the unpinned All Dictionaries tail alphabetically; true
	// preserves manual order and appends new dictionaries alphabetically. Nil
	// marks older state, whose mode the page infers from its saved order.
	CustomOrder *bool `json:"customOrder,omitempty"`

	// Full opens an article's secondary zone (DSL [*], wu-sec: examples and
	// links to sub-entries) shown instead of hidden. Spelled positively, like
	// SortMine: the brief view is Lingvo's own default, so the zero value
	// keeps it. It is the reader's last choice on a section's switch, and
	// sets how the next section opens; the server never reads it.
	Full bool `json:"full,omitempty"`

	// Mode is the search mode the reader last picked: "exact", "contains" or
	// "fts". Empty is prefix, the default, so an absent key keeps it. It is the
	// reader's habit, and which modes answer at all is a fact about this
	// server's library, so it lives here and not in the browser. The page
	// writes it only when the reader picks a mode, never when a link or the
	// history sets one; the server never reads it.
	Mode string `json:"mode,omitempty"`
}

type UserDir string