script

type Compiler interface {
	// Compile checks if a script is valid and returns it as executable content.
	// The returned ExecutableContent contains the validated and possibly compiled
	// script ready for execution.
	//
	// Parameters:
	//   - script: A pointer to the script content string
	//
	// Returns:
	//   - ExecutableContent: The validated script
	//   - error: Details about validation failures (syntax errors, undefined globals)
	Compile(scriptReader io.ReadCloser) (ExecutableContent, error)
}

type ExecutableContent interface {
	// GetSource returns the original script content as a string.
	// This is the source code before any compilation or execution.
	GetSource() string

	// GetByteCode returns the compiled bytecode of the script in a runtime-specific format.
	// This bytecode object is asserted into the type the target engine requires. If the
	// target engine is unable to assert the bytecode into the correct type, it will return
	// an error at runtime, so the engine type and ByteCode must be compatible.
	GetByteCode() any

	// GetMachineType returns the engine type this script is intended to run on.
	GetMachineType() machineTypes.Type
}

type ExecutableUnit struct {
	// ID is a unique identifier for this executable unit, typically derived from a hash of the script content.
	ID string

	// CreatedAt records when this executable unit was instantiated.
	CreatedAt time.Time

	// ScriptLoader loads the script content to local memory from various places (file, string, etc.).
	ScriptLoader loader.Loader

	// Compiler is the script language-specific compiler that was used to compile this unit.
	Compiler Compiler

	// Content holds the compiled bytecode and source representation of the script.
	Content ExecutableContent

	// DataProvider provides access to both static compile-time data and variable runtime data
	// during script evaluation. Enabling the "compile once, run many times" design.
	// When created with NewExecutableUnit, this is typically a CompositeProvider containing
	// a StaticProvider (for compile-time data) and another provider (for runtime data).
	DataProvider data.Provider
	// contains filtered or unexported fields
}

type MockCompiler struct {
	mock.Mock
}

type MockExecutableContent struct {
	mock.Mock
}