core

var (
	MODES          = []string{COLOR_AUTO, COLOR_ALWAYS, COLOR_NEVER}
	NO_CONSTRAINTS []string

	FlagHelp                 BoolRadArg
	FlagDebug                BoolRadArg
	FlagRadDebug             BoolRadArg
	FlagColor                StringRadArg
	FlagQuiet                BoolRadArg
	FlagShell                BoolRadArg
	FlagVersion              BoolRadArg
	FlagConfirmShellCommands BoolRadArg
	FlagSrc                  BoolRadArg
	FlagCstTree              BoolRadArg
	FlagAstTree              BoolRadArg
	FlagRadArgsDump          BoolRadArg
	FlagMockResponse         StringRadArg
	FlagRepl                 BoolRadArg
	FlagTlsInsecure          BoolRadArg
	FlagInteractive          BoolRadArg

	// GlobalFlagScopes is the single source of truth for global flag ordering
	// (as printed in usage) and scope. Rebuilt by CreateAndRegisterGlobalFlags.
	GlobalFlagScopes []ScopedGlobalFlag
)

var (
	RRootCmd                 *ra.Cmd
	RConfig                  *RadConfig
	RP                       Printer
	RIo                      RadIo
	RExit                    *RadExitHandler
	RForceExit               func(int) // hard exit that skips defers; for double-Ctrl+C
	RReq                     *Requester
	RClock                   Clock
	RSleep                   func(ctx context.Context, duration time.Duration)
	RShell                   ShellExecutor
	RConfirm                 func(title string, prompt string) (bool, error)
	RSignal                  SignalSource
	RInteractive             InteractiveDriver
	RNG                      *rand.Rand
	HasScript                bool
	ScriptPath               string
	ScriptDir                string
	ScriptName               string
	IsTest                   bool
	AlreadyExportedShellVars bool
	RTermWidth               *int // nil = use real terminal width; non-nil overrides for tests

	StartEpochMillis int64
)

var ATTR_STRINGS = make([]string, 0)

var COLOR_STRINGS = make([]string, 0)

var Cmds []EmbeddedCmd

var CmdsByName map[string]EmbeddedCmd

var EMPTY_STR = NewRadString("")

var FuncColorize = BuiltInFunc{
	Name: FUNC_COLORIZE,
	Execute: func(f FuncInvocation) RadValue {
		strVal := ToPrintableQuoteStr(f.GetArg("_val"), false)
		enum := lo.Uniq(f.GetList("_enum").AsStringList(false))
		skipIfSingle := f.GetBool("skip_if_single")

		if len(enum) == 0 {
			return f.ReturnErrf(rl.ErrEmptyList, "Possible values list cannot be empty, but was.")
		}

		if skipIfSingle && len(enum) == 1 {
			s := NewRadString(strVal)
			return f.Return(s)
		}

		sort.Strings(enum)

		if !lo.Contains(enum, strVal) {
			return f.ReturnErrf(rl.ErrColorizeValNotInEnum,
				"Value '%s' not found in the provided list of possible values: %s",
				strVal,
				enum)
		}

		r, g, b, err := GetEnumColor(strVal, enum)
		if err != nil {
			return f.ReturnErrf(rl.ErrEmptyList, "Failed to get color for value '%s': %s", strVal, err.Error())
		}

		s := NewRadString(strVal)
		s.SetRgb(r, g, b)
		return f.Return(s)
	},
}

var FuncConvertDuration = BuiltInFunc{
	Name: FUNC_CONVERT_DURATION,
	Execute: func(f FuncInvocation) RadValue {
		value := f.GetFloat("_value")
		unit := f.GetStr("_unit").Plain()

		var nanosFloat float64
		switch unit {
		case "nanos":
			nanosFloat = value
		case "micros":
			nanosFloat = value * float64(time.Microsecond)
		case "millis":
			nanosFloat = value * float64(time.Millisecond)
		case "seconds":
			nanosFloat = value * float64(time.Second)
		case "minutes":
			nanosFloat = value * float64(time.Minute)
		case "hours":
			nanosFloat = value * float64(time.Hour)
		case "days":
			nanosFloat = value * 24 * float64(time.Hour)
		default:
			bugIncorrectTypes(FUNC_CONVERT_DURATION)
			panic(UNREACHABLE)
		}

		if math.IsNaN(nanosFloat) || math.IsInf(nanosFloat, 0) || math.Abs(nanosFloat) > float64(math.MaxInt64) {
			return f.ReturnErrf(rl.ErrNumInvalidRange, "Duration overflow: value too large for %s", unit)
		}

		return f.Return(NewDurationMap(int64(nanosFloat)))
	},
}

var FuncDebug = BuiltInFunc{
	Name: FUNC_DEBUG,
	Execute: func(f FuncInvocation) RadValue {
		RP.ScriptDebug(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncExit = BuiltInFunc{
	Name: FUNC_EXIT,
	Execute: func(f FuncInvocation) RadValue {
		err := f.GetIntAllowingBool("_code")
		exit(f.i, err)
		return VOID_SENTINEL
	},
}

var FuncInternalCheckFromLogs = BuiltInFunc{
	Name: INTERNAL_FUNC_CHECK_FROM_LOGS,
	Execute: func(f FuncInvocation) RadValue {

		raw := strings.TrimSpace(f.GetStr("_duration").Plain())
		d, err := ParseDuration(raw)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidCheckDuration, "Invalid duration: %s", err.Error())
		}
		if d < 0 {
			return f.ReturnErrf(rl.ErrInvalidCheckDuration, "Duration cannot be negative: %s", raw)
		}
		durationMillis := d.Milliseconds()

		verbose := f.GetBool("_verbose")
		strict := f.GetBool("_strict")

		scripts := parseInvocationLogs(f.i, f.callNode, durationMillis)

		sortScriptsByLastOccurrence(scripts)

		durationDesc := raw
		if durationMillis == 0 {
			durationDesc = "all time"
		}
		RP.Printf("Found %d scripts in invocation logs (checking within %s)...\n\n", len(scripts), durationDesc)

		chk, err := check.NewChecker()
		if err != nil {

			chk = nil
			RP.RadStderrf("Warning! Failed to init checker once, will init per file: %v\n", err)
		}
		if chk != nil {
			chk.SetStrict(strict)
		}

		results := make([]scriptResult, 0, len(scripts))
		maxPathLen := 0
		for i, script := range scripts {
			RP.RadDebugf("Checking script %d/%d: %s", i+1, len(scripts), script.Path)
			if !com.IsRegularFile(script.Path) {
				RP.RadDebugf("  skipped (not a regular file)")
				results = append(results, scriptResult{Path: script.Path, Skipped: true})
				continue
			}
			checkStart := time.Now()
			counts, ok := checkScriptWith(script.Path, chk, strict)
			RP.RadDebugf("  checked in %s (ok=%t, errors=%d)", time.Since(checkStart), ok, counts.Errors)
			r := scriptResult{Path: script.Path, Counts: counts, Ok: ok}
			results = append(results, r)
			if len(script.Path) > maxPathLen {
				maxPathLen = len(script.Path)
			}
		}

		// Column headers and their widths
		type col struct {
			Header string
			Width  int
		}
		cols := []col{
			{"Errors", 6},
			{"Warns", 5},
			{"Info", 5},
			{"Hints", 5},
		}

		faint := color.New(color.Faint)
		green := color.New(color.FgGreen)
		red := color.New(color.FgRed)
		yellow := color.New(color.FgYellow)
		cyan := color.New(color.FgCyan)
		blue := color.New(color.FgBlue)

		colsWidth := 0
		for _, c := range cols {
			colsWidth += 2 + c.Width
		}
		tableWidth := 4 + maxPathLen + colsWidth

		hasDataRows := false
		for _, r := range results {
			if !r.Skipped {
				hasDataRows = true
				break
			}
		}
		if hasDataRows {
			headerLine := fmt.Sprintf("    %-*s", maxPathLen, "")
			for _, c := range cols {
				headerLine += fmt.Sprintf("  %*s", c.Width, c.Header)
			}
			RP.Printf("%s\n", faint.Sprint(headerLine))
		}

		totalChecked, passed, failed, skipped, loadErrors := 0, 0, 0, 0, 0
		var totalCounts diagCounts

		for _, r := range results {
			if r.Skipped {
				skipped++
				if verbose {
					RP.Printf("  %s\n", faint.Sprintf("- %s (not found or not a regular file)", r.Path))
				}
				continue
			}

			totalChecked++
			totalCounts.Errors += r.Counts.Errors
			totalCounts.Warnings += r.Counts.Warnings
			totalCounts.Infos += r.Counts.Infos
			totalCounts.Hints += r.Counts.Hints

			isFail := !r.Ok || r.Counts.Errors > 0
			if isFail {
				failed++
			} else {
				passed++
			}
			if !r.Ok {
				loadErrors++
			}

			// Status icon
			var icon string
			if isFail {
				icon = red.Sprint("✗")
			} else {
				icon = green.Sprint("✓")
			}

			line := fmt.Sprintf("  %s %-*s", icon, maxPathLen, r.Path)

			if r.Ok {
				line += formatCount(r.Counts.Errors, cols[0].Width, red, faint)
				line += formatCount(r.Counts.Warnings, cols[1].Width, yellow, faint)
				line += formatCount(r.Counts.Infos, cols[2].Width, cyan, faint)
				line += formatCount(r.Counts.Hints, cols[3].Width, blue, faint)
			} else {
				line += "  " + faint.Sprint("(load error)")
			}

			RP.Printf("%s\n", line)
		}

		sepWidth := tableWidth
		if sepWidth < 40 {
			sepWidth = 40
		}
		RP.Printf("\n%s\n", strings.Repeat("─", sepWidth))

		bold := color.New(color.Bold)

		summary := fmt.Sprintf("Checked %d scripts: %s passed, %s failed",
			totalChecked,
			green.Sprintf("%d", passed),
			red.Sprintf("%d", failed))

		// Append non-zero diagnostic/status details in a single parenthetical
		var detailParts []string
		if totalCounts.Errors > 0 {
			noun := "errors"
			if totalCounts.Errors == 1 {
				noun = "error"
			}
			detailParts = append(detailParts, red.Sprintf("%d %s", totalCounts.Errors, noun))
		}
		if loadErrors > 0 {
			noun := "load errors"
			if loadErrors == 1 {
				noun = "load error"
			}
			detailParts = append(detailParts, faint.Sprintf("%d %s", loadErrors, noun))
		}
		if totalCounts.Warnings > 0 {
			noun := "warnings"
			if totalCounts.Warnings == 1 {
				noun = "warning"
			}
			detailParts = append(detailParts, yellow.Sprintf("%d %s", totalCounts.Warnings, noun))
		}
		if totalCounts.Infos > 0 {
			noun := "info diagnostics"
			if totalCounts.Infos == 1 {
				noun = "info diagnostic"
			}
			detailParts = append(detailParts, cyan.Sprintf("%d %s", totalCounts.Infos, noun))
		}
		if totalCounts.Hints > 0 {
			noun := "hints"
			if totalCounts.Hints == 1 {
				noun = "hint"
			}
			detailParts = append(detailParts, blue.Sprintf("%d %s", totalCounts.Hints, noun))
		}
		if skipped > 0 {
			detailParts = append(detailParts, faint.Sprintf("%d skipped", skipped))
		}
		if len(detailParts) > 0 {
			summary += " (" + strings.Join(detailParts, ", ") + ")"
		}

		RP.Printf("%s.\n", bold.Sprint(summary))

		if failed > 0 {
			RExit.Exit(1)
		} else {
			RExit.Exit(0)
		}
		return VOID_SENTINEL
	},
}

var FuncMatches = BuiltInFunc{
	Name: FUNC_MATCHES,
	Execute: func(f FuncInvocation) RadValue {
		input := f.GetStr("_str").Plain()
		pattern := f.GetStr("_pattern").Plain()
		partial := f.GetBool("partial")

		re, err := regexp.Compile(pattern)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
		}

		var matches bool
		if partial {
			matches = re.FindString(input) != ""
		} else {

			anchoredPattern := "^(?:" + pattern + ")$"
			anchoredRe, err := regexp.Compile(anchoredPattern)
			if err != nil {
				return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
			}
			matches = anchoredRe.MatchString(input)
		}

		return f.Return(matches)
	},
}

var FuncMultipick = BuiltInFunc{
	Name: FUNC_MULTIPICK,
	Execute: func(f FuncInvocation) RadValue {

		options := f.GetList("_options").AsStringList(false)

		if len(options) == 0 {
			return f.Return(NewErrorStrf("Cannot multipick from empty options list"))
		}

		minArg := f.GetArg("min")
		maxArg := f.GetArg("max")
		promptArg := f.GetArg("prompt")

		min := int64(0)
		if !minArg.IsNull() {
			min = minArg.RequireInt(f.i, f.callNode)
		}

		if min < 0 {
			return f.Return(NewErrorStrf("min must be non-negative, got %d", min))
		}

		// Get max value (optional)
		var max *int64
		if !maxArg.IsNull() {
			maxVal := maxArg.RequireInt(f.i, f.callNode)
			max = &maxVal

			if maxVal <= 0 {
				return f.Return(NewErrorStrf("max must be positive, got %d", maxVal))
			}

			if min > maxVal {
				return f.Return(NewErrorStrf("min (%d) cannot be greater than max (%d)", min, maxVal))
			}
		}

		if min > int64(len(options)) {
			if min == 1 {
				return f.Return(NewErrorStrf("min is 1 but there are no options available"))
			} else {
				return f.Return(NewErrorStrf("min is %d but only %d options available", min, len(options)))
			}
		}

		// Generate smart default prompt if not provided
		var prompt string
		if promptArg.IsNull() {
			prompt = generateMultipickPrompt(min, max)
		} else {
			prompt = f.GetStr("prompt").Plain()
		}

		model := radish.NewMultiSelect().
			Title(prompt).
			Options(options...).
			Min(int(min)).
			Width(GetTermWidth())
		if max != nil {
			model.Max(int(*max))
		}

		res, _, err := RInteractive.Run(model)
		if err != nil {
			if errors.Is(err, radish.ErrNotInteractive) {
				return f.Return(NewErrorStrf("multipick requires an interactive terminal"))
			}
			return f.Return(NewErrorStrf("Error running multipick: %v", err))
		}
		if res.Canceled {
			return f.Return(NewErrorStrf("multipick canceled"))
		}

		result := NewRadList()
		for _, item := range model.Selected() {
			result.Append(newRadValueStr(item))
		}

		return f.Return(result)
	},
}

var FuncPPrint = BuiltInFunc{
	Name: FUNC_PPRINT,
	Execute: func(f FuncInvocation) RadValue {
		item := f.GetArg("_item")

		jsonStruct := RadToJsonType(item)
		output := prettify(f.i, f.callNode, jsonStruct)
		RP.Print(output)
		return VOID_SENTINEL
	},
}

var FuncParseDate = BuiltInFunc{
	Name: FUNC_PARSE_DATE,
	Execute: func(f FuncInvocation) RadValue {
		dateStr := f.GetStr("_date").Plain()
		formatArg := f.GetArg("format")
		tz := f.GetStr("tz").Plain()

		// Resolve output timezone
		var location *time.Location
		if tz == "local" {
			location = RClock.Local()
		} else {
			var err error
			location, err = time.LoadLocation(tz)
			if err != nil {
				return f.ReturnErrf(rl.ErrInvalidTimeZone, "Invalid time zone '%s'", tz)
			}
		}

		if dateStr == "" {
			return f.Return(NewErrorStr("Cannot parse an empty date string").SetCode(rl.ErrParseDate))
		}

		var parsedTime time.Time

		if !formatArg.IsNull() {

			format := formatArg.RequireStr(f.i, f.callNode).Plain()
			if format == "" {
				return f.Return(NewErrorStr("Cannot parse date with an empty format string").SetCode(rl.ErrParseDate))
			}
			goLayout := convertFormatToGoLayout(format)

			t, err := time.ParseInLocation(goLayout, dateStr, location)
			if err != nil {
				errMsg := fmt.Sprintf("Failed to parse date %q with format %q", dateStr, format)
				return f.Return(NewErrorStr(errMsg).SetCode(rl.ErrParseDate))
			}
			parsedTime = t
		} else {
			// Auto-detect: try known unambiguous formats
			var parsed bool
			for _, af := range autoDetectFormats {
				if af.hasTz {
					t, err := time.Parse(af.layout, dateStr)
					if err == nil {
						parsedTime = t.In(location)
						parsed = true
						break
					}
				} else {
					t, err := time.ParseInLocation(af.layout, dateStr, location)
					if err == nil {
						parsedTime = t
						parsed = true
						break
					}
				}
			}

			if !parsed {
				errMsg := fmt.Sprintf(
					"Failed to parse date %q. Supported formats: YYYY-MM-DD, YYYY-MM-DDTHH:mm:ss, "+
						"YYYY-MM-DD HH:mm:ss (with optional timezone offset and fractional seconds). "+
						"Use 'format' to specify a custom format, e.g. parse_date(%q, format=\"DD/MM/YYYY\").",
					dateStr, dateStr,
				)
				return f.Return(NewErrorStr(errMsg).SetCode(rl.ErrParseDate))
			}
		}

		return f.Return(NewTimeMap(parsedTime))
	},
}

var FuncParseDuration = BuiltInFunc{
	Name: FUNC_PARSE_DURATION,
	Execute: func(f FuncInvocation) RadValue {
		durStr := f.GetStr("_duration").Plain()

		nanos, err := ParseDurationString(durStr)
		if err != nil {
			return f.ReturnErrf(rl.ErrParseDuration, "Failed to parse duration %q: %s", durStr, err)
		}

		return f.Return(NewDurationMap(nanos))
	},
}

var FuncPick = BuiltInFunc{
	Name: FUNC_PICK,
	Execute: func(f FuncInvocation) RadValue {
		options := f.GetList("_options").AsStringList(false)
		filterArg := f.GetArg("_filter")

		filters := make([]string, 0)
		if !filterArg.IsNull() {
			switch coerced := filterArg.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK)
			}
		}

		keyGroups := lo.Map(options, func(key string, _ int) []string { return []string{key} })
		prioExact := f.GetBool(namedArgPreferExact)
		str, err := pickKv(f, keyGroups, keyGroups, filters, prioExact)
		if err != nil {
			return f.Return(err)
		}

		return f.Return(str[0])
	},
}

var FuncPickFromResource = BuiltInFunc{
	Name: FUNC_PICK_FROM_RESOURCE,
	Execute: func(f FuncInvocation) RadValue {
		path := f.GetStr("path").Plain()
		filter := f.GetArg("_filter")

		resource, err := LoadPickResource(f.i, f.callNode, path)
		if err != nil {
			return f.Return(err)
		}

		var keyGroups [][]string
		var valueGroups [][]RadValue
		for _, opt := range resource.Opts {
			keyGroups = append(keyGroups, opt.Keys)
			valueGroups = append(valueGroups, opt.Values)
		}

		filters := make([]string, 0)
		if !filter.IsNull() {
			switch coerced := filter.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK_KV)
			}
		}

		prioExact := f.GetBool(namedArgPreferExact)
		out, err := pickKv(f, keyGroups, valueGroups, filters, prioExact)

		if err != nil {
			return f.Return(err)
		}

		if len(out) == 1 {
			return newRadValues(f.i, f.callNode, out[0])
		} else {
			return newRadValues(f.i, f.callNode, out)
		}
	},
}

var FuncPickKv = BuiltInFunc{
	Name: FUNC_PICK_KV,
	Execute: func(f FuncInvocation) RadValue {
		keys := f.GetList("keys").AsStringList(false)
		values := f.GetList("values").Values
		filter := f.GetArg("_filter")

		filters := make([]string, 0)
		if !filter.IsNull() {
			switch coerced := filter.Val.(type) {
			case RadString:
				filters = append(filters, coerced.Plain())
			case *RadList:
				for _, item := range coerced.Values {
					filters = append(filters, item.RequireStr(f.i, f.callNode).Plain())
				}
			default:
				bugIncorrectTypes(FUNC_PICK_KV)
			}
		}

		keyGroups := lo.Map(keys, func(key string, _ int) []string { return []string{key} })
		valueGroups := lo.Map(values, func(value RadValue, _ int) []RadValue { return []RadValue{value} })

		prioExact := f.GetBool(namedArgPreferExact)
		out, err := pickKv(f, keyGroups, valueGroups, filters, prioExact)
		if err != nil {
			return f.Return(err)
		}
		return f.Return(out[0])
	},
}

var FuncPrint = BuiltInFunc{
	Name: FUNC_PRINT,
	Execute: func(f FuncInvocation) RadValue {
		RP.Print(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncPrintErr = BuiltInFunc{
	Name: FUNC_PRINT_ERR,
	Execute: func(f FuncInvocation) RadValue {
		RP.ScriptStderrf(resolvePrintStr(f))
		return VOID_SENTINEL
	},
}

var FuncRand = BuiltInFunc{
	Name: FUNC_RAND,
	Execute: func(f FuncInvocation) RadValue {
		return f.Return(RNG.Float64())
	},
}

var FuncRandInt = BuiltInFunc{
	Name: FUNC_RAND_INT,
	Execute: func(f FuncInvocation) RadValue {
		arg1 := f.GetInt("_arg1")
		arg2 := f.GetArg("_arg2")

		var min, max int64

		if arg2.IsNull() {
			min = 0
			max = arg1
		} else {
			min = arg1
			max = arg2.RequireInt(f.i, f.callNode)
		}

		if min >= max {
			return f.ReturnErrf(rl.ErrArgsContradict, "min (%d) must be less than max (%d).", min, max)
		}

		n := max - min
		return newRadValues(f.i, f.callNode, min+RNG.Int63n(n))
	},
}

var FuncRange = BuiltInFunc{
	Name: FUNC_RANGE,
	Execute: func(f FuncInvocation) RadValue {
		useFloats := false

		arg1 := f.GetArg("_arg1")
		arg2 := f.GetArg("_arg2")
		step := f.GetArg("_step")

		for _, arg := range []RadValue{arg1, arg2, step} {
			switch arg.Type() {
			case rl.RadFloatT:
				useFloats = true
			case rl.RadIntT, rl.RadNullT:
			default:
				bugIncorrectTypes(FUNC_RANGE)
			}
		}

		if useFloats {
			return runFloatRange(f, arg1, arg2, step)
		} else {
			return runIntRange(f, arg1, arg2, step)
		}
	},
}

var FuncReplace = BuiltInFunc{
	Name: FUNC_REPLACE,
	Execute: func(f FuncInvocation) RadValue {
		original := f.GetStr("_original").Plain()
		find := f.GetStr("_find").Plain()
		replace := f.GetStr("_replace").Plain()

		re, err := regexp.Compile(find)
		if err != nil {
			return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
		}

		replacementFunc := func(match string) string {
			submatches := re.FindStringSubmatch(match)

			if len(submatches) == 0 {
				return match
			}

			result := replace
			for i, submatch := range submatches {
				placeholder := fmt.Sprintf("$%d", i)
				result = strings.ReplaceAll(result, placeholder, submatch)
			}

			return result
		}

		newString := re.ReplaceAllStringFunc(original, replacementFunc)

		return f.Return(newString)
	},
}

var FuncSeedRandom = BuiltInFunc{
	Name: FUNC_SEED_RANDOM,
	Execute: func(f FuncInvocation) RadValue {
		RNG = rand.New(rand.NewSource(f.GetInt("_seed")))
		return VOID_SENTINEL
	},
}

var FuncSignalIgnore = BuiltInFunc{
	Name: FUNC_SIGNAL_IGNORE,
	Execute: func(f FuncInvocation) RadValue {
		names, err := extractSignalNames(f, "_signal", FUNC_SIGNAL_IGNORE)
		if err != nil {
			return f.Return(err)
		}
		for _, name := range names {
			if ierr := f.i.signals.Ignore(name); ierr != nil {
				return f.Return(NewErrorStrf("%v", ierr).SetCode(rl.ErrGenericRuntime))
			}
		}
		return VOID_SENTINEL
	},
}

var FuncSignalTrap = BuiltInFunc{
	Name: FUNC_SIGNAL_TRAP,
	Execute: func(f FuncInvocation) RadValue {
		names, err := extractSignalNames(f, "_signal", FUNC_SIGNAL_TRAP)
		if err != nil {
			return f.Return(err)
		}
		handler := f.GetFn("_handler")
		for _, name := range names {
			if terr := f.i.signals.Trap(name, handler); terr != nil {
				return f.Return(NewErrorStrf("%v", terr).SetCode(rl.ErrGenericRuntime))
			}
		}
		return VOID_SENTINEL
	},
}

var FuncSleep = BuiltInFunc{
	Name: FUNC_SLEEP,
	Execute: func(f FuncInvocation) RadValue {
		duration := f.GetArg("_duration")
		switch coerced := duration.Val.(type) {
		case int64:
			err := sleep(f.i, time.Duration(coerced)*time.Second, f.namedArgs)
			if err != nil {
				return f.Return(err)
			}
			return VOID_SENTINEL
		case float64:
			err := sleep(f.i, time.Duration(coerced*1000)*time.Millisecond, f.namedArgs)
			if err != nil {
				return f.Return(err)
			}
			return VOID_SENTINEL
		case RadString:
			durStr := coerced.Plain()

			floatVal, err := rts.ParseFloat(durStr)
			if err == nil {
				err := sleep(f.i, time.Duration(floatVal*1000)*time.Millisecond, f.namedArgs)
				if err != nil {
					return f.Return(err)
				}
				return VOID_SENTINEL
			}

			nanos, err := ParseDurationString(durStr)
			if err == nil {
				err := sleep(f.i, time.Duration(nanos), f.namedArgs)
				if err != nil {
					return f.Return(err)
				}
				return VOID_SENTINEL
			}

			return f.ReturnErrf(rl.ErrSleepStr, "Invalid string argument: %q", coerced.Plain())
		default:
			bugIncorrectTypes(FUNC_SLEEP)
			panic(UNREACHABLE)
		}
	},
}

var FuncSplit = BuiltInFunc{
	Name: FUNC_SPLIT,
	Execute: func(f FuncInvocation) RadValue {
		toSplit := f.GetStr("_val").Plain()
		splitter := f.GetStr("_sep").Plain()

		limitArg := f.GetArg("limit")
		limit := -1
		if !limitArg.IsNull() {
			limitVal := limitArg.RequireInt(f.i, f.callNode)
			if limitVal < 1 {
				return f.Return(NewErrorStrf("limit must be at least 1, got %d", limitVal).SetCode(rl.ErrNumInvalidRange))
			}

			limit = int(limitVal) + 1
		}

		return f.Return(regexSplit(f.i, f.callNode, toSplit, splitter, limit))
	},
}

var FuncSplitLines = BuiltInFunc{
	Name: FUNC_SPLIT_LINES,
	Execute: func(f FuncInvocation) RadValue {
		toSplit := f.GetStr("_val").Plain()
		return f.Return(splitLines(f.i, f.callNode, toSplit))
	},
}

var FuncToJson = BuiltInFunc{
	Name: FUNC_TO_JSON,
	Execute: func(f FuncInvocation) RadValue {
		indent := f.GetInt("indent")
		if indent < 0 {
			return f.ReturnErrf(rl.ErrNumInvalidRange, "Indent must be non-negative, got %d", indent)
		}

		jsonStruct := RadToJsonType(f.GetArg("_val"))

		buf := &bytes.Buffer{}
		enc := json.NewEncoder(buf)

		enc.SetEscapeHTML(false)
		if indent > 0 {
			enc.SetIndent("", strings.Repeat(" ", int(indent)))
		}
		if err := enc.Encode(jsonStruct); err != nil {
			return f.ReturnErrf(rl.ErrInternalBug, "Failed to serialize to JSON: %v", err)
		}

		return f.Return(strings.TrimSuffix(buf.String(), "\n"))
	},
}

var FunctionsByName map[string]BuiltInFunc

var (
	NO_NAMED_ARGS_INPUT = map[string]namedArg{}
)

var RAD_NULL = RadNull{}

var RAD_NULL_VAL = newRadValue(nil, nil, RAD_NULL)

var VOID_SENTINEL = RadValue{Val: 0x0}

var VoidBreak = NewEvalResult(VOID_SENTINEL, CtrlBreak)

var VoidContinue = NewEvalResult(VOID_SENTINEL, CtrlContinue)

var VoidNormal = NewEvalResult(VOID_SENTINEL, CtrlNormal)