core

type AssertExpr struct {
	Condition string
	Message   string
}

type Associativity uint8

type Atom struct {
	Name      string
	Params    map[string]string
	Modifiers []string
	Args      map[string]*Value
	Prompt    string
	Targets   []string
	Excludes  []string
}

type AtomAdviseFunc func(atom *Atom, builder *action.Builder[any, any]) error

type AtomSpec struct {
	Name        string          `json:"name"`
	Description string          `json:"description,omitempty"`
	Tags        []string        `json:"tags,omitempty"`
	Scope       string          `json:"scope,omitempty"`
	ReqFields   []FieldSpec     `json:"req_fields,omitempty"`
	ResFields   []FieldSpec     `json:"res_fields,omitempty"`
	Example     json.RawMessage `json:"example,omitempty"`
}

type BoundarySpec struct {
	Name        string
	Description string
	Consume     func(stream action.AnyStreamAction) *action.Builder[any, any]
}

type BuildContext struct {
	Resolver  CapabilityResolver
	Modifiers *ModifierTable
	Advisers  []AtomAdviseFunc
}

type Bundle struct {
	ID           string
	Alias        string // Dynamiczny namespace nadpisywany przez @require (np. "as ft")
	Libraries    []action.Library
	Directives   []Directive
	Modifiers    []Modifier
	Operators    []Operator
	Primaries    []PrimaryExtension
	Materialize  Materializer
	OnPreprocess func(meta map[string]any) PreprocessContributions
	AtomAdvise   func(atom *Atom, builder *action.Builder[any, any]) error
	WrapPipeline func(meta map[string]any, inner action.AnyAction) (action.AnyAction, error)

	SelfTest func() []SelfTestSection
	Fixtures fs.FS
}

type BundleFactory func(opts map[string]string) Bundle

type CapabilityContract struct {
	Name   string
	Input  TypeDescriptor
	Output TypeDescriptor
}

type CapabilityResolver interface {
	Action(name string) (action.AnyAction, bool)
	Stream(name string) (action.AnyStreamAction, bool)
	Operator(name string) (action.NamedOperator, bool)
	Mount(lib action.Library) error
	MountWithAlias(lib action.Library, alias string) error
}

type Catalog struct {
	Atoms      []AtomSpec      `json:"atoms"`
	Sources    []SourceSpec    `json:"sources"`
	Operators  []OperatorSpec  `json:"operators"`
	Modifiers  []ModifierSpec  `json:"modifiers"`
	Directives []DirectiveSpec `json:"directives"`
}

type CompileAndRunReq struct {
	Source  string
	Payload any
}

type CompileOption func(*compileConfig)

type CompileReq struct {
	Source             string
	Name               string
	Line               int
	InheritedPrimaries []PrimaryExtension
}

type CompileRes struct {
	Program action.AnyAction
	Meta    map[string]any
	AST     Expr
}

type ConditionalExpr struct {
	Cond Expr
	Then Expr
	Else Expr
}

type ContractProvider interface {
	Contract(name string) (CapabilityContract, bool)
}

type Directive struct {
	Name    string
	Example string
	Handler func(context.Context, DirectiveReq) (DirectiveRes, error)
}

type DirectiveReq struct {
	Lines   []string
	Body    []string
	I       int
	Out     map[string]any
	File    string
	BaseDir string

	// Recurse runs the full preprocess on another .nflow file and
	// returns its cleaned body plus merged metadata. Used by @include
	// so directives in included files produce declarations in the
	// parent's Out map.
	Recurse func(absPath string) (clean string, meta map[string]any, err error)
}

type DirectiveRes struct {
	Next int
}

type DirectiveSpec struct {
	Name    string `json:"name"`
	Example string `json:"example,omitempty"`
}

type DirectiveTable struct {
	// contains filtered or unexported fields
}

type DynamicResolver struct {
	// contains filtered or unexported fields
}

type Expr interface {
	Node()
	Children() []Expr
	Analyze(resolver CapabilityResolver) error
	Build(ctx context.Context, bCtx *BuildContext) (action.AnyAction, error)
}

type FallbackExpr struct{ L, R Expr }

type FieldSpec struct {
	Name     string `json:"name"`
	Type     string `json:"type"`
	Required bool   `json:"required,omitempty"`
	Usage    string `json:"usage,omitempty"`
}

type KeywordPrimary interface {
	PrimaryExtension
	Keyword() string
}

type Lexer struct {
	// contains filtered or unexported fields
}

type LoopExpr struct {
	Body  Expr
	Until string
}

type MapEntry struct {
	Key   string
	Value *Value
}

type MaterializeReq struct {
	Ctx      context.Context
	Meta     map[string]any
	Resolver CapabilityResolver
	Compile  func(name, source string) (action.AnyAction, error)
	Alias    string
}

type Materializer func(req MaterializeReq) error

type Modifier struct {
	Name    string
	Example string
	Apply   func(b *action.Builder[any, any], raw string) error
}

type ModifierSpec struct {
	Name    string `json:"name"`
	Example string `json:"example,omitempty"`
}

type ModifierTable struct {
	// contains filtered or unexported fields
}

type OnPreprocessFunc func(meta map[string]any) PreprocessContributions

type Operator struct {
	Meta    OperatorMeta
	Handler func(context.Context, OperatorReq) (OperatorRes, error)
}

type OperatorMeta struct {
	Name          string
	Token         TokenType
	Precedence    int
	Associativity Associativity
	Description   string
	Example       string
}

type OperatorReq struct {
	Left  Expr
	Right Expr
	Meta  *OperatorMeta
}

type OperatorRes struct {
	Node Expr
}

type OperatorSpec struct {
	Name        string `json:"name"`
	Token       string `json:"token,omitempty"`
	Description string `json:"description,omitempty"`
	Example     string `json:"example,omitempty"`
}

type OperatorTable struct {
	// contains filtered or unexported fields
}

type ParallelExpr struct{ Branches []Expr }

type Parser struct {
	// contains filtered or unexported fields
}

type PipeExpr struct{ L, R Expr }

type PipelineWrapFunc func(meta map[string]any, inner action.AnyAction) (action.AnyAction, error)

type Position struct {
	File string
	Line int
	Col  int
}

type PreprocessContributions struct {
	Primaries   []PrimaryExtension
	CompileOpts []CompileOption
}

type PrimaryExtension interface {
	Name() string
	Parse(p *Parser) (Expr, error)
}

type PrimaryExtensionTable struct {
	// contains filtered or unexported fields
}

type ProjectionExpr struct{ Raw string }

type RunReq struct {
	Program action.AnyAction
	Payload any
}

type RunRes struct {
	Output any
}

type SelfTestFeature struct {
	Name   string
	DSL    string
	Files  map[string]string
	Skip   string
	Source string
}

type SelfTestSection struct {
	Name     string
	Features []SelfTestFeature
}

type SourceSpec struct {
	Name        string      `json:"name"`
	Description string      `json:"description,omitempty"`
	Tags        []string    `json:"tags,omitempty"`
	ReqFields   []FieldSpec `json:"req_fields,omitempty"`
}

type Token struct {
	Type   TokenType
	Lit    string
	Line   int
	Offset int
}

type TokenPrimary interface {
	PrimaryExtension
	TokenType() TokenType
}

type TokenType uint8

type TypeDescriptor struct {
	Type   reflect.Type
	Stream bool
}

type Value struct {
	Kind  ValueKind
	Str   string
	Num   float64
	Bool  bool
	Ref   string
	Map   []MapEntry
	Slice []*Value
}

type ValueKind uint8