edit

type Conflict struct {
	Doc  string `json:"doc"`
	Name string `json:"name"`
}

type Delta struct {
	// Seq is the number of the change this delta carries. The same delta goes
	// to the tab that made the edit and to every other one over the stream, so
	// both paths dedupe on it through one entry point.
	Seq uint64 `json:"seq"`
	// Full marks the whole page rather than a patch — the answer to a client the
	// session has fallen out of step with. It is on the wire because seq alone
	// cannot say it: the client's counter moves on the answer to its own edit
	// too, and that answer carries only the blocks that edit changed. A full
	// sync numbered no higher would look like a repeat and be dropped by the
	// very tab it was sent to catch up.
	Full bool `json:"full,omitempty"`
	// Dirty holds the prefixes of the documents with edits not yet on disk. It
	// is normalised to an empty slice rather than left nil: null on the wire
	// would make indexOf throw in the browser.
	Dirty []string `json:"dirty"`
	// Conflicts names the documents whose file diverged while they held unsaved
	// edits. It travels as part of the state, not as a notification of its own:
	// a client that reconnects gets the banner along with the full sync.
	Conflicts  []Conflict `json:"conflicts,omitempty"`
	Docs       []DeltaDoc `json:"docs"`
	Warnings   []string   `json:"warnings,omitempty"`
	HasMermaid bool       `json:"hasMermaid"`
	HasKatex   bool       `json:"hasKatex"`
}

type DeltaBlock struct {
	I        int     `json:"i"`
	Editable bool    `json:"editable"`
	HTML     *string `json:"html,omitempty"`
}

type DeltaDoc struct {
	Doc     string     `json:"doc"`
	Version int        `json:"version"`
	TOC     []TOCEntry `json:"toc"`
	// Body is the whole article as one html string, sent instead of Blocks by a
	// read-only session: a reading page has no block wrappers to address, so
	// the article is replaced whole or not at all. It is nil for a document
	// that did not change, and always nil on an editing page.
	Body   *string      `json:"body,omitempty"`
	Blocks []DeltaBlock `json:"blocks,omitempty"`
}

type DiskChangedError struct {
	// Docs holds the prefixes of the diverged documents in page order — the
	// name the browser addresses a document by.
	Docs []string
	// Names holds the same documents in the same order, named the way the page
	// names them, so the message says which file to look at. A prefix is empty
	// on a single-document page and says nothing there.
	Names []string
}

type Doc struct {
	// Prefix is the anchor/article prefix this document gets on the page; "" on
	// a single-document page, where ids stay exactly what a stand-alone render
	// would produce.
	Prefix string
	// Path is the absolute path with symlinks resolved: the file Save writes to.
	Path string
	// Name is the path as typed on the command line, used for rendering and in
	// messages so they name the file the way the author does.
	Name string
	// contains filtered or unexported fields
}

type DocRef struct {
	// Path is the path as typed on the command line. It is what rendering sees:
	// relative images and links resolve against its directory, exactly as they
	// do in a run without --edit.
	Path string
	// Display is the form of the path that goes into the page as the sidebar
	// tooltip. Empty falls back to the file name alone, so a caller that forgets
	// it cannot leak an absolute path — and with it the OS user name — into a
	Display string
}

type SaveResult struct {
	Saved  []string          `json:"saved"`
	Errors map[string]string `json:"errors,omitempty"`
	// Seq is the state of the page this answer describes: the number of the
	// event the save broadcast, or the current one when it wrote nothing. The
	// answer travels on its own connection and the broadcast goes out before
	// it, so an event newer than this save can reach the browser first — the
	// number is what lets the page tell that and leave the newer state alone.
	Seq uint64 `json:"seq"`
}

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

type StaleVersionError struct {
	Doc     string
	Sent    int
	Version int
}

type State struct {
	// Docs are the documents in navigation order.
	Docs []page.Doc
	// Mermaid and Katex are the page-level asset flags, ORed over every
	// document: one diagram or formula anywhere pulls the bundle in for the
	// whole page.
	Mermaid bool
	Katex   bool
	// Warnings are the render issues of the whole page, each named by document.
	Warnings []string
	// Dirty holds the prefixes of the documents with edits not yet on disk. A
	// page built mid-session has to say so: the session it is rendered from is
	// ahead of the files, and a page that showed the edits but no way to write
	Dirty []string
	// Conflicts names the documents the session refused to re-read: their file
	// moved under unsaved edits. It travels with the page for the same reason
	// Dirty does, and one more of its own — the conflict was announced by an
	// event that is long past, and a page built afterwards has no other way to
	// learn of it. Without it a reload takes the "Перечитать" button away and
	// leaves the author with the overwrite as the only answer.
	Conflicts []Conflict
	// Seq is the number of the last change the session made. A page carries it
	// so the stream it opens afterwards can say where it already is: without it
	// a client would either re-apply the state it was built from or miss a
	// change that landed between the render and the subscription.
	Seq uint64
	// Epoch names the run of the CLI this state came from. Seq counts from zero
	// in every run, so it says where a client is only once the run it counts in
	// is known — the page carries both back, and a cursor minted in another run
	// is exactly what a full sync is for.
	Epoch string
}

type TOCEntry struct {
	Level int    `json:"level"`
	ID    string `json:"id"`
	Text  string `json:"text"`
}