delta

type Delta struct {
	// Manifest is the full state after the operations apply. Unchanged
	// boundaries appear here without an operation, which is the entire point.
	Manifest Manifest
	// Operations are ordered outermost first, so a target always exists by the
	// time a later operation addresses something inside it.
	Operations []Operation
	// Head is the merged head of the new composition. A delta reuses the live
	// document shell, so a component appearing for the first time has no link
	// tag installed; the client diffs this against the head it already has and
	// waits for new stylesheets before applying content.
	Head []string
}

type DeltaRecord struct {
	// Operation names a boundary the comparison produced. Its HTML is empty for
	// an unchanged boundary, which still carries its validator so the client can
	// rebuild the whole manifest from what it received.
	Operation *Operation
	// Frame is the validator of the boundary Operation names.
	Frame string
	// Children digests that boundary's nested boundary ids, in order, and Parent
	// names the boundary enclosing it.
	//
	// A manifest entry has three fields beside its id, and a client rebuilding
	// one from a stream must be able to return all three. Without Children every
	// list looks reordered on the request after next; without Parent a removal
	// cannot be attributed to the boundary that would report the survivors, so a
	// shrinking list falls back to replacing the outermost boundary — expensive
	// in exactly the case the children operation exists to make cheap.
	Children string
	Parent   string
	// Completion is an await boundary that settled, addressed by the
	// placeholder written during the initial pass rather than by an instance id.
	Completion *htmlbind.Content
	// Signal is an instruction a live source emitted beside its deliveries. It
	// addresses no boundary and replaces nothing, so it carries no validator
	// and no operation; the client dispatches it by name.
	Signal *htmlbind.Signal
}

type Instance struct {
	// ID identifies the same logical instance across two renders. It is derived
	// from the chain position, so changing search parameters does not rename it.
	ID string
	// ParentID is the enclosing boundary, empty for the outermost one.
	ParentID string
	// ComponentID is the generated declaration identity and version.
	ComponentID string
	// InputValidator digests the canonical declared inputs. It predicts equal
	// output only for a component whose output depends on nothing else, so it
	// is a cache and diagnostic key rather than authority to skip a render.
	InputValidator string
	// FrameValidator digests this boundary's own rendered bytes, excluding the
	// output of nested boundaries and the holes where they sit. A layout whose
	// frame is unchanged can keep its DOM while its child is replaced.
	FrameValidator string
	// ChildrenValidator digests the ids of the nested boundaries, in order.
	//
	// It is separate from the frame because the two have different remedies. A
	// changed frame means the component's own markup moved, and the parent is
	// replaced. A changed children list means a region was inserted, removed,
	// or reordered, and the parent's own DOM is fine — the client is told the
	// new order and reconciles what it already holds. Folding the second into
	// the first would make every appended list row cost the whole list.
	//
	// It is empty for a boundary with no nested boundary, which is most of them.
	ChildrenValidator string
}

type Manifest struct {
	Instances []Instance
}

type Operation struct {
	// Kind is replace. Insert, remove, and move arrive with structural
	// boundaries; until then a structural change is expressed by replacing an
	// enclosing boundary.
	Kind string
	// InstanceID names the boundary the operation targets.
	InstanceID string
	// HTML is the boundary's own markup, including its root element, with an
	// inert placeholder where each nested boundary sits rather than that
	// boundary's bytes.
	HTML string
	// Sequence addresses this fragment's static half, and Values are the varying
	// half a client walks it with. Together they reproduce HTML exactly, which
	// is what lets a caller send one or the other: the statics travel once per
	// client and the values travel per render.
	//
	// Both are empty for a boundary whose sequence could not be derived, which
	// is the case a caller falls back to HTML for.
	Sequence string
	Values   []string
	// Boundaries names the nested boundaries appearing as holes in HTML.
	//
	// It is what tells a hole to fill from one to retain: an id also carrying an
	// operation in this response is replaced, and one that does not is a
	// boundary the client already holds and moves its live node into. Nothing in
	// the markup distinguishes the two, and without the list a missing fragment
	// would be indistinguishable from a truncated response.
	Boundaries []string
}