Defaults for New. Retention is the number of most-recent revisions per page whose body stays on chain; MaxBody caps a single revision.

DepositPerByte is the storage deposit a realm write locks per byte, in ugnot (gnolang/gno#6171). It is used only to show a reader what a page costs; the chain, not this package, does the accounting.

DiffMaxLines bounds the changed region a diff will compute exactly.

The cost of an LCS over the changed region is O(n*m), and this runs inside vm/qrender, which has a gas ceiling a reader cannot raise. 80 lines caps the table at 6,400 cells; beyond it, a diff degrades to "this block was replaced" rather than making the page unrenderable. Both revisions are still available in full through the raw view, so nothing is hidden by the degradation.

MaxCommentLen bounds one comment in bytes.

MaxReplyDepth is 1: a comment replies to a top-level comment, and that is all. Deeper nesting needs recursive rendering with no natural bound, which is exactly the shape a query gas ceiling punishes.

MaxTitleLen bounds a title name in bytes, matching MediaWiki's limit.

There is deliberately no Talk namespace. Discussion is not an article with a prefix: it is an append-only thread attached to a page, which threads properly, moderates per message, and cannot be silently rewritten by whoever edits last. See talk.gno.

DiffStat counts added and removed lines.

RenderAllPages renders the page index for a namespace prefix.

RenderArticle renders a page for reading: the sanitized body with its wikilinks resolved, a header identifying the current revision, and a footer with categories and cost.

RenderBacklinks renders "what links here" for a title.

RenderCategories lists every category that has at least one member.

RenderCategory renders a category page: its own text, then its members.

RenderDiff renders the line diff between two revisions of a page.

RenderHistory renders a page's revision list, newest first.

RenderIndex renders the wiki's front page: recent changes and a page count.

RenderMissing renders the stub shown for a title with no page: the red-link destination, listing whoever already points at it.

RenderRaw renders a revision's source inside a code block, which is what a reader needs before editing and what a verifier needs to re-hash.

RenderRecent renders the recent-changes feed.

RenderRevision renders one stored revision verbatim.

RenderStats renders the wiki's size and what it is paying the chain.

RenderTalk renders a page's discussion: top-level messages oldest first, each with its replies.

RewriteLinks turns the wikilinks of an already-sanitized body into markdown links. Category declarations are removed from the flow: membership is shown by the rendered footer, not inline, which is also what MediaWiki does.

s MUST be the output of sanitize.BlockRich or sanitize.Block, and open/close MUST be the escaped delimiters. Passing a raw body here would emit links built from unsanitized bytes.

DiffLines compares two bodies line by line.

exact reports whether the result is a real line diff. When it is false the changed region was larger than DiffMaxLines and the result is the coarse form: every removed line, then every added line.

ScanLinks finds every [[target|label]] occurrence delimited by open and close.

The delimiters are parameters because the same syntax has to be found twice with different bytes. Indexing reads the raw body, where a link is "[[X]]". Rendering reads the body after sanitize.BlockRich, where the very same link is "\[\[X\]\]" because the sanitizer escapes every "[". Rendering must sanitize first and rewrite second: a rewriter that ran first would hand the markdown links it just generated to the escaper, and every link on the wiki would render as literal text.

A link whose inner text spans a newline or is empty is not a link. When a nearer opener appears inside the inner text, scanning restarts from it, so "[[a [[b]]" yields b rather than a mis-parsed a.

ParseProtection maps a user-supplied level name onto a Protection.

MustParseTitle is ParseTitle for titles known at development time.

ParseTitle normalizes a user-supplied title.

The normalization is a deliberate subset of MediaWiki's: underscores become spaces, runs of whitespace collapse, the first letter is upper-cased, and a recognized "Namespace:" prefix (case-insensitive) selects the namespace. "Talk:gno land" and "talk:Gno_land" both parse to Talk:Gno land.

The accepted character set is narrower than MediaWiki's on purpose. A title is rendered inside markdown and inside a URL path, so anything that is markdown-significant ("*", "`", "[", "|", "#", "<"), path-significant ("/", "?", "%", "&") or invisible (bidi and zero-width controls) is rejected rather than escaped. Rejecting keeps Title.String, Title.Slug and the sanitized render byte-identical, which is what TestTitleCharsSurviveSanitize pins.

New returns an empty wiki. A retention or maxBody below 1 falls back to the package default.

Action builds a transaction link for a realm function. The realm supplies it (txlink.Realm("…").Call is the usual value); a nil Action renders a page with no edit controls, which is what an archived or read-only mirror wants.

Change is a recent-changes entry: a revision plus the page it landed on.

Comment is one message in a page's discussion.

Discussion is a comment store rather than a "Talk:" article, which is the one place this design departs from MediaWiki on purpose. A talk page is an article, so the last editor can rewrite what someone else said, and moderating one bad message means editing the whole page. An append-only store gives each message its own author, its own timestamp and its own moderation, and nobody can silently rewrite anyone else's words.

Ctx carries what rendering needs from the realm: where the realm lives, and which titles exist. Its function fields are read during a single Render call and never stored, so no closure is ever persisted.

DiffLine is one line of a rendered diff.

DiffOp is what happened to one line between two revisions.

Kind labels what a revision did, for the recent-changes feed.

Link is one wikilink occurrence in a body.

Namespace partitions the title space the way MediaWiki does: the same name can exist once per namespace, and each namespace gets its own rendering and its own listing.

Page is one title's history plus the indexes derived from its current revision. Revisions live in a ulist: append is O(1) and does not rewrite the existing entries, which matters when a popular page accumulates thousands of edits and every write would otherwise re-serialize the whole slice.

Protection is a page's edit gate. The engine stores it and reports it; it never enforces it, because authority belongs to the realm that owns the wiki, not to a pure library. See Wiki.Edit.

Revision is one entry in a page's append-only history.

The exported fields are the permanent spine: they are never evicted, and they are what makes the history tamper-evident. Hash is the SHA-256 of the body bytes as submitted, so a body recovered from transaction history can be checked against the chain's own record of it.

body is the only field under a retention policy. When a revision falls out of the page's body window it is evicted, which releases the storage deposit those bytes locked.

Stats is a snapshot of the wiki's size and of what it is paying for.

Thread is a top-level comment and its replies.

Title is a normalized (namespace, name) pair. The zero Title is invalid; build one with ParseTitle.

Wiki is the whole encyclopedia: pages, the indexes derived from them, and the recent-changes feed.

Every mutating method takes author, now and height from the caller instead of reading them from the chain, so the engine has no chain imports and the tests drive time and height explicitly.