mappingplanview

type BuildResult struct {
	// FirstFailIdx is the index into Model.Fields of the first field AddField
	// rejected, or -1 when every AddField succeeded. PlanBuilder is fail-fast
	// and stateful: fields before it were accepted (→ Valid), the field at it is
	// Rejected / Conflicting, and fields after it were never reached (→ Blocked).
	FirstFailIdx int
	// FirstFailErr is the AddField error at FirstFailIdx (nil when FirstFailIdx
	// is -1). Its message classifies Rejected vs Conflicting and seeds the chip
	// reason + inspector History.
	FirstFailErr error
	// FinishErr is set when every AddField passed but Finish failed — a
	// plan-level cross-field rejection that does not pin to a single field, so
	// it is surfaced in the global verdict rather than per-field. nil otherwise.
	FinishErr error
}

type FieldRow struct {
	GoField string // DTO field name (ignored for IsConst rows)

	IsOption bool // option.Option[T] — presence, orthogonal to the value type

	Membership string // lw: first segment; "" ⇒ plain column
	Section    string // lw: second segment (plain column name when Membership == "")
	Column     string // lw: sub-column suffix after ':' (e.g. beginIncl / endExcl)

	Channel mappingplan.MembershipChannel // one of the four Cut-1 channels in v1
	Unit    bool                          // ,unit

	IsConst    bool   // declared on a `_` field as ,const=<value>
	ConstValue string // the constant value

	// IsTuple marks a dynamic-membership tuple row (ADR-0103): a
	// slice-of-struct DTO field mapping N attributes into ONE section, each
	// element carrying its own membership. The row's GoField / Section stay
	// meaningful (the outer field + its section); Membership is unused (the
	// membership is per-element data); TupleStructType names the element
	// struct; TupleElems are the element struct's fields. One tuple row is
	// one PlanBuilder call (AddTupleSliceField), so the per-field FSM chip
	// carries the whole tuple's verdict.
	IsTuple         bool
	TupleStructType string
	TupleElems      []*TupleElemRow
	// contains filtered or unexported fields
}

type FieldState uint8

type Input struct {
	// Ids is the widget ID stack. Render opens its own IdScope via
	// Ids.PrepareStr(ScopeKey) and derives a stable per-row scope from each
	// row's uid.
	Ids *c.WidgetIdStack
	// ScopeKey scopes every id Render emits. Pass a stable short string per
	// call site (e.g. "mpv").
	ScopeKey string
	// Model is the editable state, mutated in place by the editor controls.
	Model *Model
	// Recompute rebuilds the output panes from the Model. The host supplies it
	// (it owns the mappingplan / marshallgen / dql wiring); Render calls it at
	// most once per frame, only when the Model is dirty, reporting back through
	// Model.SetOutputs / Model.SetInvalid. The host must also call it once at
	// init so the dock's initial split has the output tab ids to place.
	Recompute func(*Model)
	// FillHost tells Render its host already gives it a bounded height, so it
	// must fill that rect rather than floor to dockMinHeight. The floor is a
	// scroll-host device (see dockMinHeight): the gallery is a vertically-
	// unbounded ScrollArea, so without a floor the dock collapses. Inside a
	// host that is ALREADY bounded and often shorter than the floor — a
	// dock-tab leaf — forcing the floor overflows the leaf and the nested dock
	// paints across the neighbouring panes (worse once a pane scrolls). Bounded
	// hosts set this true; the gallery leaves it false. See schemaview.Input,
	// which carries the same field, and the imzero2 SKILL "Gallery Scroll-Host
	// Layout" section for both sides of the pattern.
	FillHost bool
}

type Model struct {
	Kind        string // entity kind from the `_` field's kind: tag
	PackageName string // DTO package (header cosmetics in the preview)
	KindType    string // DTO struct type name

	Fields []*FieldRow

	// panes are the generated output artifacts shown as dock tabs, set by the
	// host's Recompute via SetOutputs; ErrText/Valid carry the verdict.
	ErrText string // PlanBuilder / emit error when !Valid
	Valid   bool
	// contains filtered or unexported fields
}

type Output struct {
	TabID  uint64
	Title  string
	Lang   OutputLang
	Source string
}

type OutputLang uint8

type PlanState uint8

type TupleElemRow struct {
	GoField      string
	IsMembership bool
	Column       string // value fields: sub-column ("" targets "value")

	// Channel is the membership element's wire channel. ADR-0103 mandates an
	// explicit verbatim channel (`,verbatim` / `,highCardVerbatim`) — ref and
	// carrier channels cannot carry a per-element membership — so the picker
	// offers exactly the verbatim pair.
	Channel mappingplan.MembershipChannel
	// MembBytes picks the membership field's Go type: string (false) or
	// []byte (true) — the two shapes AddTupleSliceField accepts.
	MembBytes bool
	// contains filtered or unexported fields
}