static

type HydrationLink struct {
	Text string
	Href string
}

type Result struct {
	Merged *capture.Merged
	// Signals feed the escalation scorer.
	Signals Signals
	// RawHTML is retained for the change-detection ladder and for the token
	// comparison that justifies the project.
	RawHTML string
	// Hydration is the prose a framework shipped as server-rendered state in a
	// typed JSON container. It is not content until something decides the page
	// produced none of its own; see HydrationText.
	Hydration []string
	// HydrationLinks are the labelled destinations from the same payload.
	HydrationLinks []HydrationLink
}

type Signals struct {
	// HTMLBytes is the size of the served document.
	HTMLBytes int
	// TextChars is how much readable text static extraction found.
	TextChars int
	// MarkupChars is how much text a naive tag-strip finds in the same bytes.
	//
	// The two together say whether static extraction is getting the page or
	// only part of it. TextChars alone cannot: three thousand characters reads
	// as a substantial page and the escalator was scoring it that way, while a
	// tag-strip of the same document found nine thousand. cuberto.com lost
	// every one of its service descriptions that way -- the escalator saw
	// "substantial text served statically", stayed at tier 0, and returned 25
	// of 34 ground-truth facts where the browser returns all 34.
	//
	// This is a crude count on purpose. It includes text a visitor never sees,
	// which is exactly why it is a floor for suspicion rather than a target:
	// the question it answers is "is there plainly more here than we extracted",
	// and only a large shortfall is worth a browser.
	MarkupChars int
	// TextRatio is TextChars over HTMLBytes. A documentation page is text with
	// a little markup around it; an application shell is markup with no text.
	TextRatio float64
	// Headings, Paragraphs and Landmarks measure structural richness. A page
	// that arrives with a real outline probably does not need rendering.
	Headings   int
	Paragraphs int
	Landmarks  int
	// Links and Images are counted because a page with many links and no prose
	// is usually an index, which static extraction handles fine.
	Links  int
	Images int
	// CanvasElements and CanvasWithSize hint at a WebGL-driven page before any
	// browser has run.
	CanvasElements int
	// ScriptBytes is how much JavaScript the page ships. A megabyte of bundle
	// with two kilobytes of text is the signature of a client-rendered site.
	ScriptBytes int
	// NoScriptWarning is set when the page ships a "you need JavaScript"
	// message, which is an explicit statement that static extraction will fail.
	NoScriptWarning bool
	// HydrationBlob is set when a framework payload is present, which means the
	// served HTML may be a shell.
	HydrationBlob bool
	// Title and Description come from the head.
	Title       string
	Description string

	// ExternalStylesheets and ComplexHidingRules record how much of the page's
	// visibility logic the static tier could not evaluate.
	//
	// This is the honest counterpart to the CSS scan: an external stylesheet is
	// not fetched, and a selector with a combinator is not resolved. Reporting
	// the counts lets the escalation scorer treat a page whose hiding logic is
	// out of reach as one worth rendering, instead of quietly assuming
	// everything it could not analyse was visible.
	ExternalStylesheets int
	ComplexHidingRules  int

	// FoldedControls and FoldedChars count the disclosures the served document
	// ships shut, and how much text they hold.
	//
	// This is the one shortfall tier 0 can see coming and can never repair. A
	// closed <details>, a panel with aria-hidden="true", an unselected tab: the
	// text is in the bytes, so MarkupChars counts it and no shortfall is
	// detected, but a reader gets it by pressing something and tier 0 has
	// nothing to press with. The page then scores as a well-served static
	// document while a third of what it says stays folded.
	//
	// Without this signal the disclosure prober was mostly unreachable in
	// practice. It only ran on pages that had already escalated for some other
	// reason, so a small, fast, entirely static page whose pricing sits behind
	// a tab -- which describes a great many real pages -- was answered from
	// tier 0 with the pricing missing and no indication anything was.
	FoldedControls int
	FoldedChars    int

	// TextRuns and ShortRuns detect split text: markup where an animation
	// library has shattered a heading into one element per character or per
	// word so each can be tweened separately.
	//
	// This is the one thing tier 0 cannot repair. Putting the pieces back
	// together needs the rendered line box and the computed style -- which
	// fragments shared a line, in what order they sat on it -- and the served
	// HTML has neither, so tier 0 emits the fragments in document order. When
	// the library also reorders the source for its effect, the result is not
	// merely ugly, it is wrong: organimo.com yields "Liitless m", "Te real h"
	// and a heading spelled out as "e / v / er / n / eed."
	//
	// Every other escalation signal here asks whether the text is present.
	// This one asks whether it is legible, which is a different question and
	// the only one that catches a page that serves all of its copy and none of
	// it readably.
	TextRuns  int
	ShortRuns int
}