officeengine

type Answer struct {
	ID int64 `json:"id"`
	OK bool  `json:"ok"`
	// Bytes is the result's size; Pages the pages the layout drew.
	Bytes int64 `json:"bytes,omitempty"`
	Pages int   `json:"pages,omitempty"`
	// Code is a failure as the Document Server's conversion API numbers it
	// (the Code* constants), so a caller says both back ends' failures the
	// same way; What is its short name for a record ("x2t-86", "trap",
	// "memory"); Error the longer English, for a log.
	Code  int    `json:"code,omitempty"`
	What  string `json:"what,omitempty"`
	Error string `json:"error,omitempty"`
	// Over: the result was larger than MaxBytes, and nothing was written.
	Over bool `json:"over,omitempty"`
	// Ms is where the time went (to_bin, layout, from_bin, convert).
	Ms map[string]int64 `json:"ms,omitempty"`
}

type ChildConfig struct {
	// Engine is the app's engine.zip, EngineSHA256 the hash it must have.
	Engine       string `json:"engine"`
	EngineSHA256 string `json:"engine_sha256"`
	// Package is the app's interface bundle (ui.zip), which holds the
	// editor's sdkjs/ and fonts/ under EditorDir; mounted read-only.
	Package       string `json:"package"`
	PackageSHA256 string `json:"package_sha256"`
	EditorDir     string `json:"editor_dir"`
	// Cache is the compilation cache's root (wazero's, and the layout's
	// bytecode), shared by every engine process of this filex.
	Cache string `json:"cache"`
	// Work is the process's own temporary directory; the parent removes it
	// when the process ends.
	Work string `json:"work"`
	// MaxMB caps every instance's memory (MiB).
	MaxMB int `json:"max_mb"`
	// Prepare: compile, start a worker of each kind once, say Prepared and
	// end - no jobs.
	Prepare bool `json:"prepare,omitempty"`
}

type Conversion struct {
	// Src is the input, From its format; To the conversion API's output type.
	Src, From, To string
	// Delimiter and CodePage are the conversion API's CSV knobs.
	Delimiter, CodePage int
	// Dst is where the result goes (it must not exist); MaxBytes its ceiling.
	Dst      string
	MaxBytes int64
}

type Error struct {
	// Code is the conversion API's number (Code*), What its short name for a
	// record ("x2t-86", "trap", "memory", "timeout", "crash").
	Code int
	What string
	// Over: the result was larger than the request's MaxBytes.
	Over bool
	Err  error
}

type Hello struct {
	// Ready: the modules are compiled, jobs may come.
	Ready bool `json:"ready,omitempty"`
	// Prepared: a Prepare run finished (the process ends after it).
	Prepared bool `json:"prepared,omitempty"`
	// Error: the process could not start (a package that does not hash to
	// its pin, a module that does not compile); it ends after saying so.
	Error     string `json:"error,omitempty"`
	CompileMs int64  `json:"compile_ms,omitempty"`
}

type Options struct {
	// Command is the argv that starts an engine process (default: this
	// executable, `office-engine`). Env is added to its environment.
	Command []string
	Env     []string
	// CacheDir is the compilation cache (filex's data directory).
	CacheDir string
	// WorkDir is where each process's temporary directory is made (default:
	// the system's).
	WorkDir string
	// MaxMB is the memory cap in force, read when a process starts.
	MaxMB func() int
	// Slots is how many processes a pool may run at once (thumbs.office_slots,
	// 1-4), read at every job.
	Slots func() int
	// ProcessLimit is the most memory a process may hold (bytes), read at
	// every job; default about twice the cap. 0 from the function: none.
	ProcessLimit func() int64
	// IdleTimeout ends a process nobody used for that long (default 3 min);
	// JobsPerProcess ends one after that many jobs (default 50).
	IdleTimeout    time.Duration
	JobsPerProcess int
	// StartTimeout bounds a process's start (default 2 min: the modules come
	// from the cache); PrepareTimeout a prepare run (default 30 min);
	// RetryPrepare is how long after a failed one it is tried again
	// (default 30 min).
	StartTimeout   time.Duration
	PrepareTimeout time.Duration
	RetryPrepare   time.Duration
	Log            *slog.Logger
}

type Package struct {
	App, Version string
	Engine       string
	EngineSHA256 string
	UI           string
	UISHA256     string
	EditorDir    string
	// HostVersion is this filex's version: a new filex (and with it a new
	// wazero) prepares the engine again.
	HostVersion string
}

type Purpose string

type Request struct {
	ID int64  `json:"id"`
	Op string `json:"op"`
	// In is the input on this machine, From its format (the extension, lower
	// case, no dot).
	In   string `json:"in"`
	From string `json:"from"`
	// To is the conversion API's output type, as the Document Server is asked
	// for it: an extension, or "pdfa".
	To string `json:"to,omitempty"`
	// Out is where the result goes. It must not exist: the child creates it.
	Out string `json:"out"`
	// MaxBytes is the largest result accepted (0: no limit). A larger one is
	// not written and the answer says Over.
	MaxBytes int64 `json:"max_bytes,omitempty"`
	// Delimiter and CodePage are the conversion API's CSV knobs (0: not said):
	// the delimiter as the Document Server numbers it (1 tab, 2 semicolon,
	// 3 colon, 4 comma, 5 space), the code page as Windows does (65001).
	Delimiter int `json:"delimiter,omitempty"`
	CodePage  int `json:"code_page,omitempty"`
	// Size is a thumbnail's box, in pixels.
	Size int `json:"size,omitempty"`
	// Params are the editor's json parameters (a Document Server's
	// m_sJsonParams): a spreadsheet's page layout for its thumbnail.
	Params json.RawMessage `json:"params,omitempty"`
}

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

type State string

type Status struct {
	State   State     `json:"state"`
	App     string    `json:"app,omitempty"`
	Version string    `json:"version,omitempty"`
	Error   string    `json:"error,omitempty"`
	Since   time.Time `json:"since"`
}

type Thumbnail struct {
	// Src is the document, From its format.
	Src, From string
	// Size is the box the page is fitted into; Params the editor's json
	// parameters (a sheet's page layout); MaxBytes the largest picture.
	Size     int
	Params   json.RawMessage
	MaxBytes int64
}