object

type ADTTypeDef struct {
	TypeName string
	Variants map[string]int
	Order    []string
}

type ADTValue struct {
	TypeName    string
	VariantName string
	FieldNames  []string
	Values      []Object
	AllVariants []string
}

type Array struct {
	Elements []Object
}

type Boolean struct {
	Value bool
}

type Break struct{}

type Builtin struct {
	Fn        BuiltinFunction
	Fn1       BuiltinFunction1
	FnWithEnv BuiltinFunctionWithEnv
	Env       *Environment
}

type BuiltinFunction func(args ...Object) Object

type BuiltinFunction1 func(arg Object) Object

type BuiltinFunctionWithEnv func(env *Environment, args ...Object) Object

type CallFrame struct {
	Function string
	Path     string
	Line     int
	Column   int
}

type Channel struct {
	Ch chan Object
}

type ClassFieldDef struct {
	Name      string
	ValueExpr ast.Expression
	Env       *Environment
	IsPrivate bool
}

type ClassInstance struct {
	Class  *ClassObject
	Fields map[string]Object
	// PrivateOwner maps a private field/method name to the name of the
	// class that declared it private, for access-control checks.
	PrivateOwner map[string]string
}

type ClassObject struct {
	Name              string
	Parent            *ClassObject
	Methods           map[string]*Function
	StaticMethods     map[string]*Function
	Fields            map[string]Object // evaluated static field values
	InstanceFieldDefs []*ClassFieldDef  // instance fields declared directly on this class
	PrivateMembers    map[string]bool   // method/static-field names declared private on this class
	IsAbstract        bool
	Builtin           *Builtin
	Implements        []string
}

type Continue struct{}

type DB struct {
	Handle any
}

type DBTx struct {
	Handle any
}

type Environment struct {
	Mu sync.RWMutex

	Store                  map[string]Object
	Constants              map[string]struct{}
	Outer                  *Environment
	ModuleContext          *ModuleContext
	ModuleDir              string
	SourcePath             string
	ModuleCache            map[string]ModuleCacheEntry
	ModuleLoading          map[string]bool
	RuntimeLimits          *RuntimeLimits
	SecurityPolicy         *SecurityPolicy
	Output                 io.Writer
	RenderConfig           *RenderConfig
	RenderArtifacts        []*RenderArtifact
	RenderArtifactSink     *[]*RenderArtifact
	CollectRenderArtifacts bool
	CallStack              []CallFrame
	OwnerID                string
	Cleanup                []func()
	YieldSink              *[]Object
	// contains filtered or unexported fields
}

type Error struct {
	Message string
	Code    string
	Path    string
	Line    int
	Column  int
	Stack   []CallFrame
	// ModuleChain records the import path of each module a runtime error
	// propagated through, outermost first (e.g. the entry script's own
	// import, then the module it imported, ...), ending with the module
	// where the error actually occurred. Populated alongside Message
	// (which still carries the same information as one concatenated
	// string, for callers - e.g. SPL try/catch - that only look at
	// Message/Inspect()) so CLI-style callers can render each hop on its
	// own line instead of parsing that string back apart.
	ModuleChain []string
	// LeafMessage is the original, unwrapped error message from the
	// innermost module (before any "module runtime error in ..." prefixes
	// were added), captured once at the point the error first occurred.
	LeafMessage string
}

type FileValue struct {
	Name       string
	Path       string
	MIME       string
	Encoding   string
	SourceType string
	Size       int64
	Data       []byte
}

type Float struct {
	Value float64
}

type Function struct {
	Name        string
	Parameters  []*ast.Identifier
	ParamTypes  []string
	Defaults    []ast.Expression
	ReturnType  string
	HasRest     bool
	Body        *ast.BlockStatement
	Env         *Environment
	IsAsync     bool
	IsGenerator bool
}

type Future struct {
	Ch     chan Object
	Result Object
	Done   bool
	Mu     sync.Mutex
}

type GeneratorValue struct {
	Elements []Object
	Env      *Environment
	Body     *ast.BlockStatement
	Func     *Function
	Index    int
	Done     bool
}

type Hash struct {
	Pairs map[HashKey]HashPair
}

type HashKey struct {
	Type  ObjectType
	Value uint64
}

type HashPair struct {
	Key   Object
	Value Object
}

type Hashable interface {
	HashKey() HashKey
}

type ImageValue struct {
	Name       string
	Path       string
	MIME       string
	Format     string
	SourceType string
	Width      int64
	Height     int64
	Data       []byte
	Image      image.Image
}

type ImmutableValue struct {
	Inner Object
}

type Integer struct {
	Value int64
}

type InterfaceLiteral struct {
	Methods map[string]*ast.InterfaceMethod
}

type LazyValue struct {
	Env       *Environment
	Expr      ast.Expression
	Evaluated bool
	Result    Object
	Mu        sync.Mutex
}

type Macro struct {
	Name       string
	Parameters []*ast.Identifier
	Body       *ast.BlockStatement
}

type ModuleCacheEntry struct {
	Exports map[string]Object
	ModTime int64
}

type ModuleContext struct {
	Exports map[string]Object
}

type Null struct{}

type Object interface {
	Type() ObjectType
	Inspect() string
}

type ObjectType int

type OwnedValue struct {
	OwnerID string
	Inner   Object
}

type RenderArtifact struct {
	Kind      string
	Source    string
	SourceTyp string
	MIME      string
	Name      string
	Alt       string
	Width     int64
	Height    int64
	MaxBytes  int64
	Mode      string
}

type RenderConfig struct {
	Mode             string
	TerminalProtocol string
	MaxBytes         int64
	AllowURLs        bool
	AllowURLHosts    []string
}

type ReturnValue struct {
	Value Object
}

type RuntimeLimits struct {
	MaxDepth           int
	CurrentDepth       int
	MaxSteps           int64
	Steps              int64
	Deadline           time.Time
	Ctx                context.Context
	MaxHeapBytes       uint64
	HeapCheckEvery     int64
	MaxOutputBytes     int64
	OutputBytes        int64
	MaxHTTPBodyBytes   int64
	MaxExecOutputBytes int64
	MaxStringBytes     int64
	MaxArrayLength     int
	MaxHashEntries     int
	MaxImportDepth     int
	CurrentImportDepth int
	MaxImportCount     int
	ImportCount        int
}

type Secret struct {
	Value string
}

type SecurityPolicy struct {
	StrictMode            bool
	ProtectHost           bool
	AllowEnvWrite         bool
	AllowedCapabilities   []string
	DeniedCapabilities    []string
	AllowedExecCommands   []string
	DeniedExecCommands    []string
	AllowedNetworkHosts   []string
	DeniedNetworkHosts    []string
	AllowedDBDrivers      []string
	DeniedDBDrivers       []string
	AllowedFileReadPaths  []string
	DeniedFileReadPaths   []string
	AllowedFileWritePaths []string
	DeniedFileWritePaths  []string
	AllowedDBDSNPatterns  []string
	DeniedDBDSNPatterns   []string
	AllowedImportPaths    []string
	DeniedImportPaths     []string
	AllowedImportPackages []string
	DeniedImportPackages  []string
	AllowedNativeModules  []string
	DeniedNativeModules   []string
	DenyDynamicImports    bool
	// BlockHardcodedSecrets, when true, rejects scripts whose source text
	// looks like it embeds a hardcoded secret (API key, private key, token,
	// ...) before parsing/eval. Detection itself is supplied by an optional
	// plugin (see security.RegisterSecretScanner, e.g. builtins/secretr) -
	// with no scanner registered this is a no-op even when set.
	BlockHardcodedSecrets bool
}

type Stream struct {
	Elements []Object
}

type String struct {
	Value string
}

type SuperBinding struct {
	ParentClass *ClassObject
	Instance    *ClassInstance
	// Call implements the bare `super(...)` form.
	Call func(callerEnv *Environment, args ...Object) Object
}

type TableValue struct {
	Name       string
	Path       string
	MIME       string
	SourceType string
	Columns    []string
	Rows       []map[string]Object
}

type TestStats struct {
	Mu     sync.Mutex
	Total  int64
	Passed int64
	Failed int64
}