resonator

type Branch struct {
	Path string `json:"path,omitempty"`
}

type BranchValue struct {
	Path  string    `json:"path,omitempty"`  // .branch.subbranch
	Value ast.Value `json:"value,omitempty"` // ast.Literal{V: 42} today; ast.PathRef / ast.FunctionCall reserved
}

type Condition struct {
	Star       bool        `json:"isStar,omitempty"`     // true = matches everything
	Branch     *Branch     `json:"branch,omitempty"`     // .branch.subbranch
	MatchType  MatchType   `json:"matchType,omitempty"`  // ==
	MatchValue interface{} `json:"matchValue,omitempty"` // 5
	// MatchCall is the function-call RHS form: `WHEN .h == &tz("UTC",
	// "hour", 9)`. Exactly one of MatchValue / MatchCall is set. The
	// parser guarantees every argument (recursively) is a literal — no
	// PathRefs — so the call is envelope-independent: a computed
	// constant, not a second path. That restriction is load-bearing:
	// it keeps path-vs-path comparison inexpressible in WHEN, which is
	// what the key-shape authorization pattern relies on.
	MatchCall *ast.FunctionCall `json:"matchCall,omitempty"`
	Adds      *BranchValue      `json:"adds,omitempty"`   // for select, adding branches
	Prunes    *BranchValue      `json:"prunes,omitempty"` // for select, removing branches
	// contains filtered or unexported fields
}

type Loop struct {
	// Until is the exit predicate, WHEN's grammar exactly (path-vs-
	// literal only, comma is AND), evaluated after every pass.
	Until *WhenExpr `json:"until,omitempty"`
	// Max is the pass ceiling. 0 means the chassis default (10); the
	// chassis also caps it with --op-loop-max.
	Max int64 `json:"max,omitempty"`
	// Every is the pause between passes. 0 means the chassis default
	// (50ms); the chassis floors it at 2ms. Checked after Until, so
	// the last pass never pays it.
	Every time.Duration `json:"every,omitempty"`
	// Set is applied before every repeat (never before the first
	// pass): resolved against the accumulated view and written onto
	// the op's input and the view. Same value forms as SET. This is
	// how a pass feeds a cursor or counter to the next one.
	Set []BranchValue `json:"set,omitempty"`
}

type MatchType string

type Phrase struct {
	Type     PhraseType
	When     *When                `json:"when,omitempty"`
	Select   *Select              `json:"select,omitempty"`
	SetPre   *Set                 `json:"setPre,omitempty"`  // set before select
	SetPost  *Set                 `json:"setPost,omitempty"` // set after select
	With     map[string]ast.Value `json:"with,omitempty"`
	Priority int64                `json:"priority"`
	Exec     string               `json:"exec,omitempty"`
	Emit     *Set                 `json:"emit,omitempty"`
	Loop     *Loop                `json:"loop,omitempty"`
}

type PhraseType string

type Resonator struct {
	When     *When                `json:"when,omitempty"`
	Select   *Select              `json:"select,omitempty"`
	SetPre   *Set                 `json:"setPre,omitempty"`  // set before select
	SetPost  *Set                 `json:"setPost,omitempty"` // set after select
	With     map[string]ast.Value `json:"with,omitempty"`
	Priority int64                `json:"priority"`
	Exec     string               `json:"exec,omitempty"`
	// Emit overlays values onto THIS rule's response after EXEC,
	// before the per-scope merge. Overwrite semantics (not the
	// set-if-absent behavior of SET POST). Lets a rule contribute
	// literal fields to the merged scope output without needing a
	// real HTTP/handler call: pair with EXEC for "enrich the
	// response", or write EMIT alone for a "synthetic emitter".
	Emit *Set `json:"emit,omitempty"`
	// Loop is the LOOP clause: re-run this rule's EXEC inside one
	// dispatch until Until holds. nil means the op runs once.
	Loop *Loop `json:"loop,omitempty"`
}

type Select struct {
	Star        bool               `json:"star,omitempty"`
	Assignments []SelectAssignment `json:"assignments,omitempty"`
}

type SelectAssignment struct {
	From       string    `json:"from"`
	To         string    `json:"to"`
	Default    ast.Value `json:"default,omitempty"`
	HasDefault bool      `json:"has_default,omitempty"`
}

type Set struct {
	Overrides []BranchValue `json:"overrides,omitempty"`
}

type When struct {
	// Expr is the canonical tree shape produced by the parser. New rules
	// always populate Expr.
	Expr *WhenExpr `json:"expr,omitempty"`
	// Conditions is the legacy flat-AND shape. Programmatic callers (and
	// any in-flight JSON written before the grammar v2 upgrade) populate
	// this; WhenMatches promotes it to an Expr at evaluation time.
	Conditions []Condition `json:"conditions,omitempty"`
}

type WhenExpr struct {
	And     []WhenExpr `json:"and,omitempty"`
	Or      []WhenExpr `json:"or,omitempty"`
	Not     *WhenExpr  `json:"not,omitempty"`
	Leaf    Condition  `json:"leaf,omitempty"`
	HasLeaf bool       `json:"has_leaf,omitempty"`
	Star    bool       `json:"star,omitempty"`
}