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
	FlagTlsInsecure          BoolRadArg
	FlagInteractive          BoolRadArg
	FlagReply                StringListRadArg
	FlagReplyNa              StringListRadArg

	// 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
	RTerminal    TerminalSource
	// RReplies holds the answers supplied via --reply / --reply-na, bound to the
	// prompt sites they address. nil when the script has no prompts.
	RReplies   *prompts.Replies
	RNG        *rand.Rand
	HasScript  bool
	ScriptPath string
	ScriptDir  string
	ScriptName string
	IsTest     bool
	// RawArgs is the caller's argv after the rad binary, as they typed it. A
	// stdin script has its `-` stripped from os.Args before the run proper, so
	// os.Args can't be used to reproduce the original invocation.
	RawArgs                  []string
	AlreadyExportedShellVars bool
	RTermWidth               *int // nil = use real terminal width; non-nil overrides for tests
	RTermHeight              *int // nil = use real terminal height; 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 ErrNoTerminal = errors.New("no terminal available")

var FuncBaseName = BuiltInFunc{
	Name: FUNC_BASE_NAME,
	Execute: func(f FuncInvocation) RadValue {
		path := f.GetStr("_path").Plain()
		return f.Return(NormalizePath(filepath.Base(path)))
	},
}

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 FuncDirName = BuiltInFunc{
	Name: FUNC_DIR_NAME,
	Execute: func(f FuncInvocation) RadValue {
		path := f.GetStr("_path").Plain()
		return f.Return(NormalizePath(filepath.Dir(path)))
	},
}

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

var FuncFormatEpoch = BuiltInFunc{
	Name: FUNC_FORMAT_EPOCH,
	Execute: func(f FuncInvocation) RadValue {
		epoch := f.GetInt("_epoch")
		format := f.GetStr("_format").Plain()
		tz := f.GetStr("tz").Plain()
		unit := f.GetStr("unit").Plain()

		if format == "" {
			return f.ReturnErrf(rl.ErrCannotFormat, "Cannot format epoch with an empty format string")
		}

		isNegative := epoch < 0
		absEpoch := epoch
		if isNegative {
			absEpoch = -absEpoch
		}

		second, nanoSecond, _, errVal := resolveEpochUnit(f, FUNC_FORMAT_EPOCH, absEpoch, unit)
		if errVal != nil {
			return *errVal
		}

		if isNegative {
			second = -second
			nanoSecond = -nanoSecond
		}

		location, errVal := resolveTimeLocation(f, tz)
		if errVal != nil {
			return *errVal
		}

		goTime := time.Unix(second, nanoSecond).In(location)
		return f.Return(goTime.Format(convertFormatToGoLayout(format)))
	},
}

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 FuncJoinPaths = BuiltInFunc{
	Name: FUNC_JOIN_PATHS,
	Execute: func(f FuncInvocation) RadValue {
		parts := f.GetList("_parts")
		strs := make([]string, 0, parts.LenInt())
		for _, v := range parts.Values {
			strs = append(strs, v.RequireStr(f.i, f.callNode).Plain())
		}
		return f.Return(NormalizePath(filepath.Join(strs...)))
	},
}

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 FuncMkdir = BuiltInFunc{
	Name: FUNC_MKDIR,
	Execute: func(f FuncInvocation) RadValue {
		path := com.ExpandTilde(f.GetStr("_path").Plain())

		newResult := func(created bool) RadValue {
			resultMap := NewRadMap()
			resultMap.SetPrimitiveStr(constPath, NormalizePath(path))
			resultMap.SetPrimitiveBool(constCreated, created)
			return f.Return(resultMap)
		}

		if stat, err := os.Stat(path); err == nil {
			if stat.IsDir() {
				return newResult(false)
			}
			return f.ReturnErrf(rl.ErrFileWrite, "Cannot create directory %q: path exists and is not a directory", NormalizePath(path))
		}

		if err := os.MkdirAll(path, 0755); err != nil {
			if os.IsPermission(err) {
				return f.Return(NewErrorStr(err.Error()).SetCode(rl.ErrFileNoPermission))
			}
			return f.Return(NewErrorStr(err.Error()).SetCode(rl.ErrFileWrite))
		}

		return newResult(true)
	},
}

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()
		}

		if answer, outcome := takeReply(f.callNode); outcome != prompts.NoReply {
			if outcome != prompts.Answered {
				return f.Return(unansweredPromptErr(f.callNode, outcome, fmt.Sprintf("The multipick %q", prompt)))
			}
			selected, radErr := multipickFromReply(answer.List, options, min, max, prompt)
			if radErr != nil {
				return f.Return(radErr)
			}
			return f.Return(selected)
		}

		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(unansweredPromptErr(f.callNode, prompts.NoReply, fmt.Sprintf("The multipick %q", prompt)))
			}
			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()

		if !f.GetBool("regex") {
			return f.Return(strings.ReplaceAll(original, find, replace))
		}

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

		return f.Return(replaceAllExpanding(re, original, replace))
	},
}

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()
		useRegex := f.GetBool("regex")

		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
		}

		var parts []string
		if useRegex {
			re, err := regexp.Compile(splitter)
			if err != nil {
				return f.ReturnErrf(rl.ErrInvalidRegex, "Error compiling regex pattern: %s", err)
			}
			parts = re.Split(toSplit, limit)
		} else if limit < 0 {
			parts = strings.Split(toSplit, splitter)
		} else {
			parts = strings.SplitN(toSplit, splitter, limit)
		}

		result := make([]RadValue, 0, len(parts))
		for _, part := range parts {
			result = append(result, newRadValue(f.i, f.callNode, part))
		}

		return f.Return(result)
	},
}

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)