template

type AndExpr ¶

type AndExpr struct {
	L, R Expr
}

AndExpr models `L && R` (left-associative chain via nested AndExpr).

type BoolLit ¶

type BoolLit struct{ Value bool }

type CmpExpr ¶

type CmpExpr struct {
	Op   string
	L, R Expr
}

CmpExpr models a single non-associative comparison `L <op> R`. Op is one of "==", "!=", "<", "<=", ">", ">=".

type EvalError ¶

type EvalError struct {
	Code string
	Msg  string
}

EvalError is the typed runtime error returned by Substitute / EvalBool. The Msg field includes any positional context as free text (e.g. "slot scan at offset N"); a structured Pos field is deferred until Phase 6's OTel projection has a consumer for it.

func EvalErrf(code, format string, args ...any) *EvalError

func (e *EvalError) Error() string

type Expr ¶

type Expr interface {
	// contains filtered or unexported methods
}

Expr is the AST sum type for parsed condition expressions. Concrete kinds: *OrExpr, *AndExpr, *NotExpr, *CmpExpr, *Ref, *StringLit, *NumberLit, *BoolLit, *NullLit. Sealed by exprMarker — linters (go-check-sumtype / exhaustive) enforce exhaustive switches in consumers.

func ParseExpr(src string) (Expr, error)

type NotExpr ¶

type NotExpr struct {
	X Expr
}

NotExpr models `!X` (right-associative via nesting: `!!a` → NotExpr{NotExpr{Ref a}}).

type NullLit ¶

type NullLit struct{}

type NumberLit ¶

type NumberLit struct{ Value json.Number }

type OrExpr ¶

type OrExpr struct {
	L, R Expr
}

OrExpr models `L || R` (left-associative chain via nested OrExpr).

type Ref ¶

type Ref struct {
	Segments []Segment
}

Ref is a reference path: IDENT ( "." IDENT | "." INT )*. First segment is always an ident. Use Segments[0].Pos for "start of ref" diagnostics; per-segment Pos enables pointing at the specific failing segment (e.g. "step `triage` not declared" → Segments[1].Pos).

func ParseRef(src string) (*Ref, error)

func References(e Expr) []Ref

type Scope ¶

type Scope interface {
	Resolve(ref *Ref) (any, error)
}

Scope is the value source the evaluator and substituter consume. The single- method shape keeps the template package engine-free: engine.Scope (slice 2.3 in engine/scope.go) implements it from *RunState + *ir.Workflow + a runtime context path. Test code can implement it from a flat map (see mapScope in eval_test.go) — the evaluator's mechanics are exercised in isolation that way.

The returned value is the typed reference value — one of: string, bool, float64, int, json.Number, map[string]any, []any, nil. The size check (AWF4001) is the evaluator's responsibility, NOT the Scope's — the Scope just returns the value; the evaluator applies MaxInlineBytes after.

type Segment ¶

type Segment struct {
	Ident   string // populated when IsIndex is false
	Index   int    // populated when IsIndex is true (non-negative integer)
	IsIndex bool
	Pos     int
}

Segment is one ref segment. Exactly one of {Ident set, IsIndex true} holds; the other is zero. Pos is the byte offset of this segment's token in the source — preserved so validation can point at the specific failing segment (e.g. `step.triage.field` → "triage" unknown at pos 5).

type Slot ¶

type Slot struct {
	Start, End int
	Inner      string
}

Slot is a `{{ … }}` region inside a host Template string. Start/End are byte offsets in the host source ([Start, End) covers the literal `{{` and `}}` markers as well as the inner text). Inner is the text between `{{` and `}}` (no trimming — the caller decides what counts as surrounding whitespace).

Positions reported by errors from ParseRef(slot.Inner) are slot-local. To translate a slot- local offset N to the host string, callers compute hostPos = slot.Start + 2 + N (the +2 is the byte length of the `{{` opener). Slice 1.4's validator MUST perform this translation before emitting a Diagnostic, otherwise reported positions are off by `slot.Start + 2`.

func Slots(src string) ([]Slot, error)

type StringLit ¶

type StringLit struct{ Value string }

StringLit, NumberLit, BoolLit, NullLit cover the literal production. NumberLit holds the raw token text as a json.Number so the evaluator (Phase 2) can choose int/float decoding without loss; in this slice nothing decodes the value, it just round-trips the source.

type SyntaxError ¶

type SyntaxError struct {
	Pos int
	Msg string
}

SyntaxError is the typed error returned by Lex / ParseExpr / ParseRef on any deviation from the §B grammar. Pos is the byte offset into the source; Msg is a short, position-free message. Callers extract Pos programmatically via errors.As(err, &se) — avoids the substring-match-on- the-rendered-message fragility we hit elsewhere.

func (e *SyntaxError) Error() string

type Token ¶

type Token struct {
	Kind TokenKind
	Text string // for TIdent: the identifier; for TNumber: the raw number literal (may include leading '-' and decimal point); for TString: decoded content
	Pos  int
}

Token is one lexed token. Pos is the byte offset into the source.

func Lex(src string) ([]Token, error)

type TokenKind ¶

type TokenKind int

TokenKind enumerates the token kinds produced by Lex. The exhaustive switch in the parser is enforced by go-check-sumtype / exhaustive linters (configured at the module level).

const (
	TEOF TokenKind = iota
	TIdent
	TNumber
	TString
	TDot
	TLParen
	TRParen
	TOr  // ||
	TAnd // &&
	TNot // !
	TEq  // ==
	TNeq // !=
	TLt  // <
	TLe  // <=
	TGt  // >
	TGe  // >=
)

func (k TokenKind) String() string