core

ExampleAbs normalises a signed value through `Abs` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Abs(-42))

Output:
42

ExampleAddAsset adds an embedded asset through `AddAsset` for embedded asset packaging. Asset packing, mounting, and extraction stay declarative for consumers.

AddAsset("example.embed", "hello.txt", "H4sIAAAAAAAC/8pIzcnJBwQAAP//hqYQNgUAAAA=")
r := GetAsset("example.embed", "hello.txt")
Println(r.Value)

Output:
hello

ExampleAfter shows the channel-returning timer used in select for timeouts. Pair with a body select-case to bound any blocking read.

ch := make(chan string, 1)
ch <- "msg"
select {
case msg := <-ch:
	Println(msg)
case <-After(100 * Millisecond):
	Println("timeout")
}

Output:
msg

ExampleAllocsPerRun measures a function's allocation rate — the SPOR seam AssertAllocs gates through.

Println(AllocsPerRun(100, func() {}))

Output:
0

ExampleArch returns the host CPU architecture through `Arch` (e.g. "arm64", "amd64").

Println(Arch())

ExampleArgBool reads a boolean argument through `ArgBool` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(ArgBool(2, "deploy", 8080, true))

Output:
true

ExampleArgInt reads an integer argument through `ArgInt` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(ArgInt(1, "deploy", 8080))

Output:
8080

ExampleArgString reads a string argument through `ArgString` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(ArgString(0, "deploy", 8080))

Output:
deploy

ExampleArgs returns the command-line arguments through `Args`.

Println(len(Args()) > 0)

Output:
true

ExampleAs extracts a typed error through `As` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := E("worker.Run", "failed", nil)
var target *Err
Println(As(err, &target))
Println(target.Operation)

Output:
true
worker.Run

b := AsBytes("homelab")
Println(len(b))

Output:
7

s := AsString([]byte("codex"))
Println(s)

Output:
codex

ExampleAssertAllocs gates a hot path's allocation ceiling through `AssertAllocs` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertAllocs(t, 0, func() { _ = Abs(-1) })

ExampleAssertCLI demonstrates the canonical CLI test shape: build a Core, register a process.run handler (typically dappco.re/go-process in production code, an in-test fake here), then dispatch a CLITest case that asserts on stdout substring and OK status.

c := New()
c.Action("process.run", func(ctx Context, opts Options) Result {
	return Result{Value: "go version go1.26.0\n", OK: true}
})

tc := CLITest{
	Cmd:      "go",
	Args:     []string{"version"},
	WantOK:   true,
	Contains: "go1.26",
}
r := c.Process().Run(Background(), tc.Cmd, tc.Args...)
Println(r.OK)
Println(Contains(r.Value.(string), tc.Contains))

Output:
true
true

ExampleAssertCLI_stubProcess dispatches a CLITest case through `AssertCLI` for AX-10 binary validation. Like assert_example_test.go's helpers, this is compiled but not executed (no "Output:" comment): AssertCLI takes a live TB, which an Example function signature can never supply. cli_example_test.go already declares `ExampleAssertCLI` (attached to cli.go, documenting the same dispatch by calling c.Process() directly) — this file's file-aware requirement is for the cli_assert.go symbol itself, so this variant calls the real AssertCLI helper the symbol names instead of redeclaring an identical duplicate under a different file.

var t *T
c := New()
c.Action("process.run", func(ctx Context, opts Options) Result {
	return Result{Value: "go version go1.26.0\n", OK: true}
})

AssertCLI(t, c, CLITest{
	Cmd: "go", Args: []string{"version"},
	WantOK: true, Contains: "go1.26",
})

ExampleAssertCLIs runs a table of CLI scenarios through `AssertCLIs` for AX-10 binary validation. Compiled but not executed (no "Output:" comment): AssertCLIs takes a live *T, which an Example function signature can never supply.

var t *T
c := New()
c.Action("process.run", func(ctx Context, opts Options) Result {
	return Result{Value: "go version go1.26.0\n", OK: true}
})

AssertCLIs(t, c, []CLITest{
	{Name: "version", Cmd: "go", Args: []string{"version"}, WantOK: true, Contains: "go1."},
	{Name: "vet", Cmd: "go", Args: []string{"vet", "./..."}, WantOK: true},
})

ExampleAssertContains asserts membership through `AssertContains` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertContains(t, []string{"alpha", "bravo"}, "bravo")

ExampleAssertContains_map asserts key membership through `AssertContains` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertContains(t, map[string]int{"x": 1}, "x")

ExampleAssertElementsMatch asserts unordered list equality through `AssertElementsMatch` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertElementsMatch(t, []string{"alpha", "bravo"}, []string{"bravo", "alpha"})

ExampleAssertElementsMatch_ints asserts unordered int-slice equality through `AssertElementsMatch` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertElementsMatch(t, []int{1, 2, 3}, []int{3, 2, 1})

ExampleAssertEmpty asserts emptiness through `AssertEmpty` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertEmpty(t, []string{})

ExampleAssertEmpty_string asserts an empty string through `AssertEmpty` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertEmpty(t, "")

ExampleAssertEqual asserts equal values through `AssertEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertEqual(t, "expected", "expected")

ExampleAssertEqual_numeric asserts equal integers through `AssertEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertEqual(t, 4, len("core"))

ExampleAssertError asserts an error through `AssertError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertError(t, AnError, "sentinel")

ExampleAssertError_wrapped asserts a wrapped error through `AssertError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertError(t, Wrap(AnError, "example", "detail"))

ExampleAssertErrorIs asserts wrapped error identity through `AssertErrorIs` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertErrorIs(t, Wrap(AnError, "example", "wrapped"), AnError)

ExampleAssertErrorIs_sentinel asserts a wrapped sentinel error through `AssertErrorIs` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertErrorIs(t, Wrap(ErrNotExist, "lookup", "missing"), ErrNotExist)

ExampleAssertFalse asserts a false condition through `AssertFalse` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertFalse(t, len("") > 0)

ExampleAssertFalse_withMessage asserts a false condition with context through `AssertFalse` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
items := []string{}
AssertFalse(t, len(items) > 0, "items must be empty")

ExampleAssertGreater asserts greater-than order through `AssertGreater` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertGreater(t, 3, 2)

ExampleAssertGreater_string asserts string ordering through `AssertGreater` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertGreater(t, "b", "a")

ExampleAssertGreaterOrEqual asserts greater-or-equal order through `AssertGreaterOrEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertGreaterOrEqual(t, 3, 3)

ExampleAssertGreaterOrEqual_duration asserts elapsed-time ordering through `AssertGreaterOrEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
elapsed := 5 * Second
minDuration := 2 * Second
AssertGreaterOrEqual(t, elapsed, minDuration)

ExampleAssertInDelta asserts approximate numeric equality through `AssertInDelta` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertInDelta(t, 1.0, 1.01, 0.02)

ExampleAssertInDelta_exact asserts exact numeric equality (zero delta) through `AssertInDelta` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertInDelta(t, 2.5, 2.5, 0)

ExampleAssertLen asserts length through `AssertLen` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLen(t, []string{"alpha", "bravo"}, 2)

ExampleAssertLen_string asserts string length through `AssertLen` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLen(t, "agent", 5)

ExampleAssertLess asserts less-than order through `AssertLess` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLess(t, 2, 3)

ExampleAssertLess_string asserts string ordering through `AssertLess` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLess(t, "a", "b")

ExampleAssertLessOrEqual asserts less-or-equal order through `AssertLessOrEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLessOrEqual(t, 3, 3)

ExampleAssertLessOrEqual_float asserts float ordering through `AssertLessOrEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertLessOrEqual(t, 1.5, 2.5)

ExampleAssertNil asserts nil through `AssertNil` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNil(t, nil)

ExampleAssertNil_typedNil asserts a typed-nil interface value through `AssertNil` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
var p *int
var v any = p
AssertNil(t, v)

ExampleAssertNoError asserts no error through `AssertNoError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNoError(t, nil)

ExampleAssertNoError_withMessage asserts no error with context through `AssertNoError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNoError(t, nil, "setup phase")

ExampleAssertNotContains asserts absence through `AssertNotContains` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotContains(t, []string{"alpha", "bravo"}, "charlie")

ExampleAssertNotContains_string asserts substring absence through `AssertNotContains` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotContains(t, "agent dispatch", "missing")

ExampleAssertNotEmpty asserts non-emptiness through `AssertNotEmpty` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotEmpty(t, []string{"alpha"})

ExampleAssertNotEmpty_map asserts a non-empty map through `AssertNotEmpty` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotEmpty(t, map[string]int{"x": 1})

ExampleAssertNotEqual asserts different values through `AssertNotEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotEqual(t, "old", "new")

ExampleAssertNotEqual_numeric asserts different integers through `AssertNotEqual` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotEqual(t, 1, 2)

ExampleAssertNotNil asserts a non-nil value through `AssertNotNil` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotNil(t, "value")

ExampleAssertNotNil_pointer asserts a non-nil pointer through `AssertNotNil` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotNil(t, &struct{}{})

ExampleAssertNotPanics asserts non-panicking behaviour through `AssertNotPanics` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotPanics(t, func() { /* no-op closure demonstrates non-panicking call */ })

ExampleAssertNotPanics_arithmetic asserts a non-panicking closure through `AssertNotPanics` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertNotPanics(t, func() { _ = 10 / 2 })

ExampleAssertPanics asserts panic behaviour through `AssertPanics` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertPanics(t, func() { panic("boom") })

ExampleAssertPanics_error asserts a panic carrying an error value through `AssertPanics` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertPanics(t, func() { panic(AnError) })

ExampleAssertPanicsWithError asserts panic error text through `AssertPanicsWithError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertPanicsWithError(t, "sentinel", func() { panic(AnError) })

ExampleAssertPanicsWithError_nonError asserts panic text from a non-error value through `AssertPanicsWithError` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertPanicsWithError(t, "boom", func() { panic("boom") })

ExampleAssertSame asserts pointer identity through `AssertSame` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
a := &struct{}{}
b := a // a second reference to the same pointer
AssertSame(t, a, b)

ExampleAssertSame_core asserts pointer identity on a Core singleton through `AssertSame` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
c := New()
// Core() returns the receiver itself, so this is genuine identity
// between two independently obtained references, not a self-compare.
AssertSame(t, c, c.Core())

ExampleAssertTrue asserts a true condition through `AssertTrue` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
AssertTrue(t, len("core") > 0)

ExampleAssertTrue_withMessage asserts a true condition with context through `AssertTrue` for AX-native tests. Passing assertions are silent while failures stay one-line and AI-readable.

var t *T
items := []string{"agent"}
AssertTrue(t, len(items) > 0, "items must not be empty")

ExampleBase64Encode encodes bytes as base64 through `Base64Encode` for token and payload encoding. Byte and string encoders return predictable wrapper values for tokens and payloads.

Println(Base64Encode([]byte("hello")))

Output:
aGVsbG8=

ExampleBase64URLEncode encodes bytes for URL-safe base64 through `Base64URLEncode` for token and payload encoding. Byte and string encoders return predictable wrapper values for tokens and payloads.

Println(Base64URLEncode([]byte("hello?")))

Output:
aGVsbG8_

ExampleCast casts a Result value through `Cast` for Result-based control flow. Success, fallback, casting, and error inspection all use the same Result shape.

r := Result{Value: "hello", OK: true}
s, ok := Cast[string](r)
Println(s, ok)

Output:
hello true

ExampleCeil rounds a value up through `Ceil` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Ceil(3.1))

Output:
4

ExampleClamp constrains a value to a range through `Clamp` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Clamp(15, 0, 10))

Output:
10

ExampleCleanPath normalises a path through `CleanPath` for workspace path handling. Path joins, cleanup, globbing, and extension changes use core wrappers.

Println(CleanPath("/tmp//file", "/"))
Println(CleanPath("a/b/../c", "/"))
Println(CleanPath("deploy/to/homelab", "/"))

Output:
/tmp/file
a/c
deploy/to/homelab

ExampleClone returns an independent copy of a string through `Clone`.

Println(Clone("agent"))

Output:
agent

ExampleCloseStream closes a stream through `CloseStream` for sandboxed file operations. File reads, writes, walks, and cleanup stay sandbox-aware through Fs.

CloseStream(NewReader("not a closer"))
Println("ok")

Output:
ok

ExampleCompare orders two values through `Compare` for priority comparison. Ordering decisions use the core comparison wrapper rather than importing cmp directly.

Println(Compare("alpha", "bravo"))
Println(Compare(42, 42))
Println(Compare(9, 3))

Output:
-1
0
1

ExampleConcat concatenates text through `Concat` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(Concat("hello", " ", "world"))

Output:
hello world

ExampleConfigGet reads a typed config value through `ConfigGet` for service configuration. Callers write untyped settings and read back typed values or enabled features.

cfg := (&Config{}).New()
cfg.Set("host", "localhost")
Println(ConfigGet[string](cfg, "host"))

Output:
localhost

ExampleContains checks text membership through `Contains` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(Contains("hello world", "world"))
Println(Contains("hello world", "mars"))

Output:
true
false

ExampleContainsAny reports whether any listed rune is present through `ContainsAny`.

Println(ContainsAny("agent", "xyz"))
Println(ContainsAny("agent", "ge"))

Output:
false
true

ExampleContainsRune reports whether a rune is present through `ContainsRune`.

Println(ContainsRune("agent", 'g'))

Output:
true

ExampleCopyValue copies between slice Values through `CopyValue`.

dst := MakeSlice(TypeFor[[]int](), 3, 3)
Println(CopyValue(dst, dst))

Output:
3

ExampleCount counts non-overlapping occurrences through `Count`.

Println(Count("banana", "a"))

Output:
3

ExampleCut splits a header line on its first separator, taking both halves and whether the separator was present in one pass.

name, value, found := Cut("Authorization: Bearer abc", ": ")
Println(name)
Println(value)
Println(found)

Output:
Authorization
Bearer abc
true

ExampleCutPrefix splits off a leading prefix through `CutPrefix`.

after, found := CutPrefix("agent.go", "agent.")
Println(after, found)

Output:
go true

ExampleCutSuffix splits off a trailing suffix through `CutSuffix`.

before, found := CutSuffix("agent.go", ".go")
Println(before, found)

Output:
agent true

ExampleDebug writes a debug event through `Debug` for operator logging. Loggers support levels, redaction, and default routing for operator output.

old := Default()
defer SetDefault(old)

buf := NewBuffer()
log := NewLog(LogOptions{Level: LevelDebug, Output: buf})
log.StyleTimestamp = func(string) string { return "00:00:00" }
SetDefault(log)
Debug("trace")
Println(Contains(buf.String(), "[DBG] trace"))

Output:
true

ExampleDeepEqual compares nested values through `DeepEqual` for runtime inspection. Reflection stays behind a narrow core surface for rare inspection code.

Println(DeepEqual([]int{1, 2, 3}, []int{1, 2, 3}))

Output:
true

ExampleE builds a scoped error through `E` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := E("cache.Get", "key not found", nil)
Println(Operation(err))
Println(ErrorMessage(err))

Output:
cache.Get
key not found

ExampleEnv reads environment access through `Env` for runtime diagnostics. Runtime and environment facts are exposed as stable diagnostic values.

Println(Env("OS"))   // e.g. "darwin"
Println(Env("ARCH")) // e.g. "arm64"

ExampleEnvKeys lists environment keys through `EnvKeys` for runtime diagnostics. Runtime and environment facts are exposed as stable diagnostic values.

keys := EnvKeys()
Println(len(keys) > 0)

Output:
true

ExampleEnviron returns the environment as KEY=VALUE strings through `Environ`.

Println(len(Environ()) > 0)

Output:
true

ExampleEqualFold compares two scheme names case-insensitively without allocating Lower copies of either.

Println(EqualFold("Bearer", "bearer"))

Output:
true

ExampleError writes or renders an error through `Error` for operator logging. Loggers support levels, redaction, and default routing for operator output.

old := Default()
defer SetDefault(old)

buf := NewBuffer()
log := NewLog(LogOptions{Level: LevelError, Output: buf})
log.StyleTimestamp = func(string) string { return "00:00:00" }
SetDefault(log)
Error("failed", "op", "deploy")
Println(Contains(buf.String(), `[ERR] failed op="deploy"`))

Output:
true

ExampleErrorCode reads the code from an error through `ErrorCode` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := NewCode("NOT_FOUND", "missing")
Println(ErrorCode(err))

Output:
NOT_FOUND

ExampleErrorJoin joins errors through `ErrorJoin` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := ErrorJoin(NewError("first"), NewError("second"))
Println(Contains(err.Error(), "first"))
Println(Contains(err.Error(), "second"))

Output:
true
true

ExampleErrorMessage reads the message from an error through `ErrorMessage` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := E("cache.Get", "missing", nil)
Println(ErrorMessage(err))

Output:
missing

err := Errorf("deploy failed: %s", "timeout")
Println(err.Error())

Output:
deploy failed: timeout

ExampleExit documents the package-level exit helper for call sites without a Core value. Production exit paths are documented without terminating the example test process.

// core.Exit(1) terminates the process in production
Println("package-level")

Output:
package-level

ExampleExit_packageLevel documents the package-level exit helper for call sites with no *Core in scope. Exit terminates the process for real in production, and the osExit test-hook that would let it be overridden safely is unexported (package core only) — unreachable from this external test package — so the call is shown only in comment form rather than invoked.

// core.Exit(1) terminates the process immediately; not invoked here.
Println("package-level exit path documented")

Output:
package-level exit path documented

ExampleFields tokenises a command line on whitespace, collapsing any run of spaces — unlike Split which needs an explicit separator and keeps empties.

Println(Join(",", Fields("  go   test ./... ")...))

Output:
go,test,./...

ExampleFilterArgs filters arguments through `FilterArgs` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(FilterArgs([]string{"deploy", "-test.v", "", "--target=homelab"}))

Output:
[deploy --target=homelab]

ExampleFloor rounds a value down through `Floor` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Floor(3.7))

Output:
3

ExampleFormatInt formats an integer with a base through `FormatInt` for CLI argument conversion. Numeric parsing and formatting use core helpers for CLI-friendly values.

Println(FormatInt(255, 16))

Output:
ff

ExampleFormatStackTrace formats a stack trace through `FormatStackTrace` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := Wrap(Wrap(NewError("root"), "db.Query", "failed"), "api.Get", "failed")
Println(FormatStackTrace(err))

Output:
api.Get -> db.Query

ExampleFormatUint formats an unsigned integer in a given base through `FormatUint`.

Println(FormatUint(255, 16))

Output:
ff

ExampleGetenv reads an environment variable through `Getenv`.

Setenv("CORE_EXAMPLE", "homelab")
Println(Getenv("CORE_EXAMPLE"))
Unsetenv("CORE_EXAMPLE")

Output:
homelab

ExampleGetpid returns the current process ID through `Getpid`.

Println(Getpid() > 0)

Output:
true

ExampleGetppid returns the parent process ID through `Getppid`.

Println(Getppid() > 0)

Output:
true

ExampleGoVersion returns the Go runtime version through `GoVersion`.

Println(GoVersion())

ExampleHTMLEscape escapes dashboard text through `HTMLEscape` for dashboard HTML text. UI-bound strings are escaped and unescaped without importing html directly.

Println(HTMLEscape(`<span data-x="1">Core & Go</span>`))

Output:
<span data-x="1">Core & Go</span>

ExampleHTMLUnescape unescapes dashboard text through `HTMLUnescape` for dashboard HTML text. UI-bound strings are escaped and unescaped without importing html directly.

Println(HTMLUnescape("<strong>Core</strong>"))

Output:
<strong>Core</strong>

rec := NewHTTPTestRecorder()
HTTPError(rec, "missing field", StatusBadRequest)
Println(rec.Code)
Println(rec.Body.String())

Output:
400
missing field

ExampleHTTPStatusText reads status reason text through `HTTPStatusText` for a Lethean drive integration. Transport details stay behind the API wrapper while callers exchange drives, streams, and Results.

Println(HTTPStatusText(201))

Output:
Created

ExampleHasPrefix checks a text prefix through `HasPrefix` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(HasPrefix("--verbose", "--"))

Output:
true

ExampleHasSuffix checks a text suffix through `HasSuffix` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(HasSuffix("report.pdf", ".pdf"))

Output:
true

ExampleHexEncode encodes bytes as hex through `HexEncode` for token and payload encoding. Byte and string encoders return predictable wrapper values for tokens and payloads.

Println(HexEncode([]byte("hello")))

Output:
68656c6c6f

id := ID()
Println(HasPrefix(id, "id-"))

Output:
true

ExampleID_format formats an identifier through `ID` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

id := ID()
Println(HasPrefix(id, "id-"))

Output:
true

ExampleIndex finds a substring position through `Index` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(Index("key=value", "="))

Output:
3

ExampleIndexAny returns the first index of any listed rune through `IndexAny`.

Println(IndexAny("agent", "ge"))

Output:
1

ExampleInfo writes an info event through `Info` for operator logging. Loggers support levels, redaction, and default routing for operator output.

old := Default()
defer SetDefault(old)

buf := NewBuffer()
log := NewLog(LogOptions{Level: LevelInfo, Output: buf})
log.StyleTimestamp = func(string) string { return "00:00:00" }
SetDefault(log)
Info("server started", "port", 8080)
Println(Contains(buf.String(), "[INF] server started port=8080"))

Output:
true

ExampleIs matches an error through `Is` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

cause := NewError("root")
err := Wrap(cause, "worker.Run", "failed")
Println(Is(err, cause))

Output:
true

ExampleIsDigit checks a digit through `IsDigit` for input normalisation. Character checks and case conversion stay behind core unicode helpers.

Println(IsDigit('7'))

Output:
true

ExampleIsExist reports whether an error means "already exists" through `IsExist`.

r := Mkdir(TempDir(), 0o755) // TempDir already exists
if !r.OK {
	_ = IsExist(r.Value.(error))
}

ExampleIsFlag checks flag syntax through `IsFlag` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(IsFlag("--verbose"))
Println(IsFlag("deploy"))

Output:
true
false

ExampleIsLetter checks a letter through `IsLetter` for input normalisation. Character checks and case conversion stay behind core unicode helpers.

Println(IsLetter('A'))
Println(IsLetter('7'))

Output:
true
false

ExampleIsLower checks lowercase text through `IsLower` for input normalisation. Character checks and case conversion stay behind core unicode helpers.

Println(IsLower('a'))

Output:
true

ExampleIsNaN tests for not-a-number through `IsNaN` for float validation. Numeric helpers keep thresholds readable without importing math directly.

Println(IsNaN(NaN()))
Println(IsNaN(1.0))

Output:
true
false

ExampleIsNotExist reports whether an error means "not found" through `IsNotExist`.

Println(IsNotExist(ErrNotExist))

Output:
true

ExampleIsPermission reports whether an error means "permission denied" through `IsPermission`.

r := Open("/root/secret-core-example")
if !r.OK {
	_ = IsPermission(r.Value.(error))
}

ExampleIsSpace checks whitespace through `IsSpace` for input normalisation. Character checks and case conversion stay behind core unicode helpers.

Println(IsSpace('\n'))

Output:
true

ExampleIsUpper checks uppercase text through `IsUpper` for input normalisation. Character checks and case conversion stay behind core unicode helpers.

Println(IsUpper('A'))

Output:
true

ExampleItoa formats an integer through `Itoa` for CLI argument conversion. Numeric parsing and formatting use core helpers for CLI-friendly values.

Println(Itoa(42))

Output:
42

ExampleJSONMarshalString serialises a value to JSON text through `JSONMarshalString` for configuration serialisation. Serialisation and parsing return core Results for configuration payloads.

type appConfig struct {
	Host string `json:"host"`
	Port int    `json:"port"`
}
Println(JSONMarshalString(appConfig{Host: "localhost", Port: 8080}))

Output:
{"host":"localhost","port":8080}

ExampleJSONValid gates a payload without decoding it.

Println(JSONValid([]byte(`{"ok":true}`)))
Println(JSONValid([]byte(`{"ok":`)))

Output:
true
false

ExampleJoin joins text fields through `Join` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(Join("/", "deploy", "to", "homelab"))

Output:
deploy/to/homelab

ExampleJoinPath joins path segments through `JoinPath` for workspace path handling. Path joins, cleanup, globbing, and extension changes use core wrappers.

Println(JoinPath("deploy", "to", "homelab"))

Output:
deploy/to/homelab

ExampleJoinPath_utils joins path segments through `JoinPath` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

Println(JoinPath("deploy", "to", "homelab"))

Output:
deploy/to/homelab

ExampleKeccak256 hashes bytes with Keccak through `Keccak256` for Ethereum-compatible digest work. SHA3 and Keccak helpers cover Ethereum-compatible digest inputs without direct crypto imports.

sum := Keccak256([]byte("hello"))
Println(HexEncode(sum[:])[:16])

Output:
1c8aff950685c2ed

ExampleKeccak256Hex hashes bytes with Keccak and hex output through `Keccak256Hex` for Ethereum-compatible digest work. SHA3 and Keccak helpers cover Ethereum-compatible digest inputs without direct crypto imports.

Println(Keccak256Hex([]byte("hello"))[:16])

Output:
1c8aff950685c2ed

ExampleLSPDiagnosticSources lists registered diagnostic sources through `LSPDiagnosticSources`.

_ = LSPDiagnosticSources() // the names of every registered diagnostic source

ExampleLSPRegisterDiagnostic registers a diagnostic source through `LSPRegisterDiagnostic`.

LSPRegisterDiagnostic("example-linter", func(uri string, content []byte) []LSPDiagnostic {
	return nil
})
// Registered sources are global process state; no deterministic output.

ExampleLastIndex finds the last instance of a substring through `LastIndex` for command text handling. Pair with Index when consumer code needs both ends of a delimiter.

Println(LastIndex("host.example.com:8080", ":"))
Println(LastIndex("no-colon", ":"))

Output:
16
-1

ExampleLookupEnv reports whether an environment variable is set through `LookupEnv`.

Setenv("CORE_EXAMPLE", "x")
_, ok := LookupEnv("CORE_EXAMPLE")
Println(ok)
Unsetenv("CORE_EXAMPLE")

Output:
true

ExampleLower normalises text to lower case through `Lower` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

Println(Lower("HELLO"))

Output:
hello

ExampleMapClone clones a map through `MapClone` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

original := map[string]int{"api": 8080}
clone := MapClone(original)
clone["api"] = 8181

Println(original["api"])
Println(clone["api"])

Output:
8080
8181

ExampleMapFilter filters a map through `MapFilter` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

features := map[string]bool{"stable": true, "experimental": false}
enabled := MapFilter(features, func(_ string, on bool) bool { return on })
Println(MapHasKey(enabled, "stable"))
Println(MapHasKey(enabled, "experimental"))

Output:
true
false

ExampleMapHasKey checks a map key through `MapHasKey` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

Println(MapHasKey(map[string]int{"port": 8080}, "port"))

Output:
true

ExampleMapKeys lists map keys through `MapKeys` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

ports := map[string]int{"api": 8080, "admin": 9090}
keys := MapKeys(ports)
SliceSort(keys)
Println(keys)

Output:
[admin api]

ExampleMapMerge merges maps through `MapMerge` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

defaults := map[string]int{"port": 8080, "workers": 2}
overrides := map[string]int{"workers": 4}
merged := MapMerge(defaults, overrides)

Println(merged["port"])
Println(merged["workers"])

Output:
8080
4

ExampleMapValues lists map values through `MapValues` for metadata maps. Map helpers cover selection, cloning, filtering, and merging with typed values.

ports := map[string]int{"api": 8080, "admin": 9090}
values := MapValues(ports)
SliceSort(values)
Println(values)

Output:
[8080 9090]

ExampleMax selects the higher value through `Max` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Max(3, 7))

Output:
7

ExampleMin selects the lower value through `Min` for health-check thresholds. Numeric helpers keep thresholds readable without importing math directly.

Println(Min(3, 7))

Output:
3

ExampleMustCast unwraps and type-asserts a Result through `MustCast` for Result-based control flow. Success, fallback, casting, and error inspection all use the same Result shape.

n := MustCast[int](Ok(42))
Println(n)

Output:
42

ExampleMustServiceFor retrieves a required typed service through `MustServiceFor` for service registration. Services register by name and can be recovered with typed helpers.

c := New()
c.RegisterService("worker", &exampleRegisteredService{name: "worker"})
svc := MustServiceFor[*exampleRegisteredService](c, "worker")
Println(svc.name)

Output:
worker

ExampleNaN produces an IEEE-754 not-a-number through `NaN` for float sentinels. Numeric helpers keep thresholds readable without importing math directly.

Println(IsNaN(NaN()))

Output:
true

ExampleNetPipe creates an in-memory connection pair through `NetPipe` for network health checks. Network primitives are reached through core wrappers and Result-shaped calls.

left, right := NetPipe()
defer right.Close()

go func() {
	WriteString(left, "ping")
	left.Close()
}()

data := ReadAll(right)
Println(data.Value)

Output:
ping

ExampleNewBuffer creates an empty buffer through `NewBuffer` for in-memory payload assembly. Buffer creation stays on the core wrapper surface for later stream or encoding work.

buf := NewBuffer([]byte("hello"))
Println(buf.String())

empty := NewBuffer()
Println(empty.Len())

Output:
hello
0

ExampleNewBufferReader creates a bytes.Reader over a byte slice through `NewBufferReader` for HTTP body construction. Buffer creation stays on the core wrapper surface for later stream or encoding work.

rd := NewBufferReader([]byte("hello"))
out := make([]byte, 5)
rd.Read(out)
Println(string(out))

Output:
hello

ExampleNewBufferString creates a buffer from existing text through `NewBufferString` for in-memory payload assembly. Buffer creation stays on the core wrapper surface for later stream or encoding work.

buf := NewBufferString("hello world")
Println(buf.String())
Println(buf.Len())

Output:
hello world
11

ExampleNewBuilder builds text incrementally through `NewBuilder` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

b := NewBuilder()
b.WriteString("hello")
b.WriteString(" world")
Println(b.String())

Output:
hello world

ExampleNewCode creates a coded error through `NewCode` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := NewCode("NOT_FOUND", "resource missing")
Println(ErrorCode(err))
Println(ErrorMessage(err))

Output:
NOT_FOUND
resource missing

ExampleNewError creates a simple error through `NewError` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := NewError("plain error")
Println(err.Error())

Output:
plain error

ExampleNewLineScanner scans lines through `NewLineScanner` for line-oriented logs. Line scanning stays on the core wrapper surface, including larger buffer cases.

scanner := NewLineScanner(NewReader("alpha\nbravo\n"))
for scanner.Scan() {
	Println(scanner.Text())
}

Output:
alpha
bravo

ExampleNewLineScannerWithSize scans long lines through `NewLineScannerWithSize` for line-oriented logs. Line scanning stays on the core wrapper surface, including larger buffer cases.

scanner := NewLineScannerWithSize(NewReader("alpha\n"), 1024)
Println(scanner.Scan())
Println(scanner.Text())

Output:
true
alpha

ExampleNewReader creates a text reader through `NewReader` for command text handling. Text predicates and transforms stay on the core string wrapper surface.

r := ReadAll(NewReader("hello"))
Println(r.Value)

Output:
hello

ExampleNow reads the current time through `Now` for health-check timing. Durations, parsing, and timestamps use core time wrappers for service code.

Println(!Now().IsZero())

Output:
true

ExampleNumCPU returns the number of logical CPUs through `NumCPU`.

Println(NumCPU() > 0)

Output:
true

ExampleOS returns the host operating system through `OS` (e.g. "darwin", "linux").

Println(OS())

ExampleOn subscribes with a typed handler — no hand-written switch.

c := New()
On(c, func(ev ActionTaskProgress) Result {
	Println(ev.Message)
	return Ok(nil)
})
c.ACTION(ActionTaskProgress{Message: "halfway"})

Output:
halfway

ExampleOperation reads the operation from an error through `Operation` for dAppCore error handling. Operations, codes, roots, and crash reports remain inspectable through core errors.

err := E("cache.Get", "missing", nil)
Println(Operation(err))

Output:
cache.Get

ExampleParseFlag parses a flag through `ParseFlag` for CLI utility parsing. Small CLI argument utilities have predictable string and flag behaviour.

key, value, ok := ParseFlag("--target=homelab")
Println(key)
Println(value)
Println(ok)

Output:
target
homelab
true

ExamplePath constructs a clean path through `Path` for workspace path handling. Path joins, cleanup, globbing, and extension changes use core wrappers.

Println(PathBase(Path("Code", "core")))
Println(PathBase(Path("/tmp", "workspace")))

Output:
core
workspace

ExamplePathBase reads a base name through `PathBase` for workspace path handling. Path joins, cleanup, globbing, and extension changes use core wrappers.

Println(PathBase("/srv/workspaces/alpha"))

Output:
alpha