runtime

type ArrayLiteral ¶

type ArrayLiteral = ast.ArrayLiteral

type AssignStmt ¶

type AssignStmt = ast.AssignStmt

type BinaryExpr ¶

type BinaryExpr = ast.BinaryExpr

type Block ¶

type Block struct {
	Params []Param
	Body   []Statement
	Env    *Env
	// contains filtered or unexported fields
}

Block represents a closure passed to a function at runtime. It stays in the vibes package because its fields reference parser AST and the runtime Env/Script types.

func BlockOf(v Value) *Block

func (*Block) ValueBlockMarker()

type BlockLiteral ¶

type BlockLiteral = ast.BlockLiteral

type BoolLiteral ¶

type BoolLiteral = ast.BoolLiteral

type BreakStmt ¶

type BreakStmt = ast.BreakStmt

type Builtin ¶

type Builtin struct {
	Name       string
	Fn         BuiltinFunc
	AutoInvoke bool
}

Builtin represents a built-in function callable from Vibescript. It remains defined in the vibes package because BuiltinFunc references the runtime *Execution type.

func BuiltinOf(v Value) *Builtin

func (*Builtin) ValueBuiltinMarker()

type BuiltinFunc ¶

type BuiltinFunc func(exec *Execution, receiver Value, args []Value, kwargs map[string]Value, block Value) (Value, error)

BuiltinFunc is the Go function signature for built-in Vibescript functions.

type CallExpr ¶

type CallExpr = ast.CallExpr

type CallOptions ¶

type CallOptions struct {
	Globals      map[string]Value
	Capabilities []CapabilityAdapter
	AllowRequire bool
	Keywords     map[string]Value
}

CallOptions configures globals, capabilities, and other settings for a script invocation.

type CapabilityAdapter ¶

type CapabilityAdapter interface {
	Bind(binding CapabilityBinding) (map[string]Value, error)
}

CapabilityAdapter binds host capabilities into a script invocation.

func MustNewContextCapability(name string, resolver ContextCapabilityResolver) CapabilityAdapter

func MustNewDBCapability(name string, impl Database) CapabilityAdapter

func MustNewEventsCapability(name string, publisher EventPublisher) CapabilityAdapter

func MustNewJobQueueCapability(name string, impl JobQueue) CapabilityAdapter

func NewContextCapability(name string, resolver ContextCapabilityResolver) (CapabilityAdapter, error)

func NewDBCapability(name string, impl Database) (CapabilityAdapter, error)

func NewEventsCapability(name string, publisher EventPublisher) (CapabilityAdapter, error)

func NewJobQueueCapability(name string, impl JobQueue) (CapabilityAdapter, error)

type CapabilityBinding ¶

type CapabilityBinding struct {
	Context context.Context
	Engine  *Engine
}

CapabilityBinding provides execution context for adapters during binding.

type CapabilityContractProvider ¶

type CapabilityContractProvider interface {
	CapabilityContracts() map[string]CapabilityMethodContract
}

CapabilityContractProvider exposes per-method contracts for capability adapters. Contract keys must match builtin method names exposed to scripts (for example "jobs.enqueue").

type CapabilityMethodContract ¶

type CapabilityMethodContract struct {
	ValidateArgs   func(args []Value, kwargs map[string]Value, block Value) error
	ValidateReturn func(result Value) error
}

CapabilityMethodContract validates capability method calls at the boundary. These contracts run before and after a capability builtin executes.

type CaseExpr ¶

type CaseExpr = ast.CaseExpr

type CaseWhenClause ¶

type CaseWhenClause = ast.CaseWhenClause

type ClassDef ¶

type ClassDef struct {
	Name         string
	Methods      map[string]*ScriptFunction
	ClassMethods map[string]*ScriptFunction
	ClassVars    map[string]Value
	Body         []Statement
	// contains filtered or unexported fields
}

ClassDef represents a user-defined class with its methods and class-level state.

func ClassOf(v Value) *ClassDef

func (*ClassDef) ValueClassMarker()

type ClassStmt ¶

type ClassStmt = ast.ClassStmt

type ClassVarExpr ¶

type ClassVarExpr = ast.ClassVarExpr

type Config ¶

type Config struct {
	StepQuota              int
	MemoryQuotaBytes       int
	StrictEffects          bool
	RecursionLimit         int
	ModulePaths            []string
	ModuleAllowList        []string
	ModuleDenyList         []string
	RandomReader           io.Reader
	MaxCachedModules       int
	MaxSourceBytes         int
	DefaultTaskConcurrency int
	MaxTaskConcurrency     int
}

Config controls interpreter execution bounds and enforcement modes.

type ContextCapabilityResolver ¶

type ContextCapabilityResolver = contextcap.Resolver

ContextCapabilityResolver is an internal alias for contextcap.Resolver so runtime code (and tests) can keep using the short name that matches the public vibes facade.

type DBEachRequest ¶

type DBEachRequest = db.DBEachRequest

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DBFindRequest ¶

type DBFindRequest = db.DBFindRequest

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DBQueryRequest ¶

type DBQueryRequest = db.DBQueryRequest

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DBSumRequest ¶

type DBSumRequest = db.DBSumRequest

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DBUpdateRequest ¶

type DBUpdateRequest = db.DBUpdateRequest

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type Database ¶

type Database = db.Database

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DatabaseReader ¶

type DatabaseReader = db.DatabaseReader

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type DatabaseWriter ¶

type DatabaseWriter = db.DatabaseWriter

Internal aliases for db capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type Duration ¶

type Duration = value.Duration

Internal aliases for the value package types so runtime code can keep referring to short names (Value, Money, KindInt, NewNil, etc.) without repeating the value. prefix everywhere. These mirror the public re-exports in vibes/value_alias.go and exist purely to keep the runtime sources readable after the move out of package vibes.

type Engine ¶

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

Engine executes Vibescript programs with deterministic limits.

func MustNewEngine(cfg Config) *Engine

func NewEngine(cfg Config) (*Engine, error)

func (e *Engine) Builtins() map[string]Value

func (e *Engine) ClearModuleCache() int

func (e *Engine) Compile(source string) (*Script, error)

func (e *Engine) ConfigSummary() string

func (e *Engine) Execute(ctx context.Context, script string) error

func (e *Engine) RegisterBuiltin(name string, fn BuiltinFunc)

func (e *Engine) RegisterZeroArgBuiltin(name string, fn BuiltinFunc)

type EnumDef ¶

type EnumDef struct {
	Name         string
	Members      map[string]*EnumValueDef
	MembersByKey map[string]*EnumValueDef
	Order        []string
	// contains filtered or unexported fields
}

EnumDef represents a user-defined enumeration with named members.

func EnumOf(v Value) *EnumDef

func (*EnumDef) ValueEnumMarker()

type EnumMemberStmt ¶

type EnumMemberStmt = ast.EnumMemberStmt

type EnumStmt ¶

type EnumStmt = ast.EnumStmt

type EnumValueDef ¶

type EnumValueDef struct {
	Enum   *EnumDef
	Name   string
	Symbol string
	Index  int
}

EnumValueDef represents a single member within an EnumDef.

func EnumValueOf(v Value) *EnumValueDef

func (*EnumValueDef) ValueEnumValueMarker()

type Env ¶

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

Env represents a lexical scope that maps variable names to values.

Bindings live in two maps: values holds normal script bindings, while statics holds bindings whose deep size never changes after definition (builtins, per-call function clones). Statics are stored separately so memory-quota estimation can account for them in O(1) through the staticBytes counter instead of re-walking every binding on each check — the root env's builtin set dominated estimation cost otherwise.

func (e *Env) Assign(name string, val Value) bool

func (e *Env) CloneShallow() *Env

func (e *Env) Define(name string, val Value)

func (e *Env) DefineStatic(name string, val Value)

func (e *Env) Get(name string) (Value, bool)

type EventPublishRequest ¶

type EventPublishRequest = events.PublishRequest

Internal aliases for events capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type EventPublisher ¶

type EventPublisher = events.Publisher

Internal aliases for events capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type Execution ¶

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

Execution holds the runtime state for a single script evaluation.

func (exec *Execution) CallBlock(block Value, args []Value) (Value, error)

func (exec *Execution) Context() context.Context

func (exec *Execution) Step() error

type ExprStmt ¶

type ExprStmt = ast.ExprStmt

type Expression ¶

type Expression = ast.Expression

type FloatLiteral ¶

type FloatLiteral = ast.FloatLiteral

type ForStmt ¶

type ForStmt = ast.ForStmt

type FunctionStmt ¶

type FunctionStmt = ast.FunctionStmt

type HashLiteral ¶

type HashLiteral = ast.HashLiteral

type HashPair ¶

type HashPair = ast.HashPair

type Identifier ¶

type Identifier = ast.Identifier

type IfStmt ¶

type IfStmt = ast.IfStmt

type IndexExpr ¶

type IndexExpr = ast.IndexExpr

type Instance ¶

type Instance struct {
	Class *ClassDef
	Ivars map[string]Value
}

Instance represents a runtime instance of a ClassDef with its own instance variables.

func InstanceOf(v Value) *Instance

func (*Instance) ValueInstanceMarker()

type IntegerLiteral ¶

type IntegerLiteral = ast.IntegerLiteral

type InterpolatedString ¶

type InterpolatedString = ast.InterpolatedString

type IvarExpr ¶

type IvarExpr = ast.IvarExpr

type JobQueue ¶

type JobQueue = jobqueue.JobQueue

Internal aliases for jobqueue capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type JobQueueEnqueueOptions ¶

type JobQueueEnqueueOptions = jobqueue.JobQueueEnqueueOptions

Internal aliases for jobqueue capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type JobQueueJob ¶

type JobQueueJob = jobqueue.JobQueueJob

Internal aliases for jobqueue capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type JobQueueRetryRequest ¶

type JobQueueRetryRequest = jobqueue.JobQueueRetryRequest

Internal aliases for jobqueue capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type JobQueueWithRetry ¶

type JobQueueWithRetry = jobqueue.JobQueueWithRetry

Internal aliases for jobqueue capability types so runtime code (and tests) can keep referring to short names that match the public vibes facade.

type KeywordArg ¶

type KeywordArg = ast.KeywordArg

type MemberExpr ¶

type MemberExpr = ast.MemberExpr

type Money ¶

type Money = value.Money

Internal aliases for the value package types so runtime code can keep referring to short names (Value, Money, KindInt, NewNil, etc.) without repeating the value. prefix everywhere. These mirror the public re-exports in vibes/value_alias.go and exist purely to keep the runtime sources readable after the move out of package vibes.

type NextStmt ¶

type NextStmt = ast.NextStmt

type NilLiteral ¶

type NilLiteral = ast.NilLiteral

type Node ¶

type Node = ast.Node

type Param ¶

type Param = ast.Param

type ParseIssue ¶ added in v0.50.0

type ParseIssue struct {
	Pos     Position
	End     Position
	Message string
}

ParseIssue is one structured parse failure extracted from a Compile error. Pos is the 1-indexed position where the issue starts; End is the exclusive end of the offending token, or the zero Position when the parser could not determine a span. Message carries the bare error text without the position prefix or rendered code frame.

func ParseIssues(err error) []ParseIssue

type Position ¶

type Position = source.Position

Position is an internal alias for source.Position so runtime code can use the short name. AST and other internal aliases below mirror the vibes facade re-exports.

type Program ¶

type Program = ast.Program

type PropertyDecl ¶

type PropertyDecl = ast.PropertyDecl

type RaiseStmt ¶

type RaiseStmt = ast.RaiseStmt

type Range ¶

type Range = value.Range

Internal aliases for the value package types so runtime code can keep referring to short names (Value, Money, KindInt, NewNil, etc.) without repeating the value. prefix everywhere. These mirror the public re-exports in vibes/value_alias.go and exist purely to keep the runtime sources readable after the move out of package vibes.

type RangeExpr ¶

type RangeExpr = ast.RangeExpr

type ReturnStmt ¶

type ReturnStmt = ast.ReturnStmt

type RuntimeError ¶

type RuntimeError struct {
	Type      string
	Message   string
	CodeFrame string
	Frames    []StackFrame
}

RuntimeError represents a Vibescript runtime error with a call stack and source context.

func (re *RuntimeError) Error() string

func (re *RuntimeError) Unwrap() error

type ScopeExpr ¶

type ScopeExpr = ast.ScopeExpr

type Script ¶

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

Script represents a parsed Vibescript module ready for execution.

func (s *Script) Call(ctx context.Context, name string, args []Value, opts CallOptions) (Value, error)

func (s *Script) Classes() []*ClassDef

func (s *Script) Enums() []*EnumDef

func (s *Script) Function(name string) (*ScriptFunction, bool)

func (s *Script) Functions() []*ScriptFunction

type ScriptFunction ¶

type ScriptFunction struct {
	Name     string
	Params   []Param
	ReturnTy *TypeExpr
	Body     []Statement
	Pos      Position
	Env      *Env
	Exported bool
	Private  bool
	// contains filtered or unexported fields
}

ScriptFunction represents a user-defined function within a Vibescript module.

func FunctionOf(v Value) *ScriptFunction

func (*ScriptFunction) ValueFunctionMarker()

type StackFrame ¶

type StackFrame struct {
	Function string
	Pos      Position
	// Source is the module path for module-backed frames. It is empty for
	// root scripts compiled directly by an embedder.
	Source string
}

StackFrame represents a single entry in a runtime error's call stack.

type Statement ¶

type Statement = ast.Statement

type StringExpr ¶

type StringExpr = ast.StringExpr

type StringLiteral ¶

type StringLiteral = ast.StringLiteral

type StringPart ¶

type StringPart = ast.StringPart

type StringText ¶

type StringText = ast.StringText

type SymbolLiteral ¶

type SymbolLiteral = ast.SymbolLiteral

type Token ¶

type Token = ast.Token

type TokenType ¶

type TokenType = ast.TokenType

type TryStmt ¶

type TryStmt = ast.TryStmt

type TypeExpr ¶

type TypeExpr = ast.TypeExpr

type TypeKind ¶

type TypeKind = ast.TypeKind

type UnaryExpr ¶

type UnaryExpr = ast.UnaryExpr

type UntilStmt ¶

type UntilStmt = ast.UntilStmt

type Value ¶

type Value = value.Value

Internal aliases for the value package types so runtime code can keep referring to short names (Value, Money, KindInt, NewNil, etc.) without repeating the value. prefix everywhere. These mirror the public re-exports in vibes/value_alias.go and exist purely to keep the runtime sources readable after the move out of package vibes.

func NewArray(a []Value) Value

func NewAutoBuiltin(name string, fn BuiltinFunc) Value

func NewBlock(params []Param, body []Statement, env *Env) Value

func NewBool(b bool) Value

func NewBuiltin(name string, fn BuiltinFunc) Value

func NewClass(def *ClassDef) Value

func NewDuration(d Duration) Value

func NewEnum(def *EnumDef) Value

func NewEnumValue(def *EnumValueDef) Value

func NewFloat(f float64) Value

func NewFunction(fn *ScriptFunction) Value

func NewHash(h map[string]Value) Value

func NewInstance(inst *Instance) Value

func NewInt(i int64) Value

func NewMoney(m Money) Value

func NewNil() Value

func NewObject(attrs map[string]Value) Value

func NewRange(r Range) Value

func NewString(s string) Value

func NewSymbol(name string) Value

func NewTime(t time.Time) Value

type ValueKind ¶

type ValueKind = value.ValueKind

Internal aliases for the value package types so runtime code can keep referring to short names (Value, Money, KindInt, NewNil, etc.) without repeating the value. prefix everywhere. These mirror the public re-exports in vibes/value_alias.go and exist purely to keep the runtime sources readable after the move out of package vibes.

type WhileStmt ¶

type WhileStmt = ast.WhileStmt

type YieldExpr ¶

type YieldExpr = ast.YieldExpr