baobox 0.1.0

package/dist/value/mutate.d.ts

@@ -0,0 +1,3 @@
+/** In-place deep mutation: transfer all properties from source into target */
+export declare function Mutate(target: unknown, source: unknown): void;
+//# sourceMappingURL=mutate.d.ts.map

package/dist/value/mutate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutate.d.ts","sourceRoot":"","sources":["../../src/value/mutate.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,wBAAgB,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,GAAG,IAAI,CAqB7D"}

package/dist/value/parse.d.ts

@@ -0,0 +1,13 @@
+import type { StaticParse, TSchema } from '../type/schema.js';
+import type { ParseResult, SchemaError } from '../error/errors.js';
+import type { RuntimeContext } from '../shared/runtime-context.js';
+/** Error thrown when Value.Parse fails validation */
+export declare class ParseError extends Error {
+    readonly errors: SchemaError[];
+    constructor(errors: SchemaError[]);
+}
+export declare function TryParse<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): ParseResult<StaticParse<T>>;
+/** Full validation pipeline: Clone → Default → Convert → Clean → Check */
+export declare function Parse<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): StaticParse<T>;
+export type { ParseFailure, ParseResult, ParseSuccess } from '../error/errors.js';
+//# sourceMappingURL=parse.d.ts.map

package/dist/value/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["../../src/value/parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAOnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAEnE,qDAAqD;AACrD,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,MAAM,EAAE,WAAW,EAAE,CAAC;gBAC1B,MAAM,EAAE,WAAW,EAAE;CAKlC;AAED,wBAAgB,QAAQ,CAAC,CAAC,SAAS,OAAO,EACxC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAe7B;AAED,0EAA0E;AAC1E,wBAAgB,KAAK,CAAC,CAAC,SAAS,OAAO,EACrC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,CAAC,CAAC,CAMhB;AAED,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/value/patch.d.ts

@@ -0,0 +1,4 @@
+import type { DiffEdit } from './diff.js';
+/** Apply a structural delta (DiffEdit[]) to a value */
+export declare function Patch<T>(value: T, edits: DiffEdit[]): T;
+//# sourceMappingURL=patch.d.ts.map

package/dist/value/patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"patch.d.ts","sourceRoot":"","sources":["../../src/value/patch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAG1C,uDAAuD;AACvD,wBAAgB,KAAK,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,CAMvD"}

package/dist/value/pipeline.d.ts

@@ -0,0 +1,6 @@
+import type { TSchema } from '../type/schema.js';
+/** A pipeline stage that transforms a value */
+export type PipelineStage = (schema: TSchema, value: unknown) => unknown;
+/** Create a composable pipeline of value transformation stages */
+export declare function Pipeline(stages: PipelineStage[]): (schema: TSchema, value: unknown) => unknown;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/value/pipeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.d.ts","sourceRoot":"","sources":["../../src/value/pipeline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAEjD,+CAA+C;AAC/C,MAAM,MAAM,aAAa,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC;AAEzE,kEAAkE;AAClE,wBAAgB,QAAQ,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,KAAK,OAAO,CAQ9F"}

package/dist/value/pointer.d.ts

@@ -0,0 +1,8 @@
+export declare namespace Pointer {
+    function Get(value: unknown, pointer: string): unknown;
+    function Set(value: unknown, pointer: string, setValue: unknown): unknown;
+    function Delete(value: unknown, pointer: string): unknown;
+    function Has(value: unknown, pointer: string): boolean;
+    function Create(...tokens: string[]): string;
+}
+//# sourceMappingURL=pointer.d.ts.map

package/dist/value/pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer.d.ts","sourceRoot":"","sources":["../../src/value/pointer.ts"],"names":[],"mappings":"AAqFA,yBAAiB,OAAO,CAAC;IACvB,SAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAa5D;IAED,SAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,GAAG,OAAO,CA4B/E;IAED,SAAgB,MAAM,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAiB/D;IAED,SAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAY5D;IAED,SAAgB,MAAM,CAAC,GAAG,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAGlD;CACF"}

package/dist/value/repair.d.ts

@@ -0,0 +1,5 @@
+import type { StaticParse, TSchema } from '../type/schema.js';
+import type { RuntimeContext } from '../shared/runtime-context.js';
+/** Repair a value to conform to a schema. Returns a new value (does not mutate). */
+export declare function Repair<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): StaticParse<T>;
+//# sourceMappingURL=repair.d.ts.map

package/dist/value/repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repair.d.ts","sourceRoot":"","sources":["../../src/value/repair.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,WAAW,EASX,OAAO,EAGR,MAAM,mBAAmB,CAAC;AAM3B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAInE,oFAAoF;AACpF,wBAAgB,MAAM,CAAC,CAAC,SAAS,OAAO,EACtC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,CAAC,CAAC,CAehB"}

package/dist/value/result.d.ts

@@ -0,0 +1,10 @@
+import type { Static, StaticDecode, StaticEncode, StaticParse, TSchema } from '../type/schema.js';
+import type { ParseResult } from '../error/errors.js';
+import { Explain } from '../error/errors.js';
+import type { RuntimeContext } from '../shared/runtime-context.js';
+export declare function TryCreate<T extends TSchema>(schema: T, context?: RuntimeContext): ParseResult<Static<T>>;
+export declare function TryDecode<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): ParseResult<StaticDecode<T>>;
+export declare function TryEncode<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): ParseResult<StaticEncode<T>>;
+export declare function TryRepair<T extends TSchema>(schema: T, value: unknown, context?: RuntimeContext): ParseResult<StaticParse<T>>;
+export { Explain };
+//# sourceMappingURL=result.d.ts.map

package/dist/value/result.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result.d.ts","sourceRoot":"","sources":["../../src/value/result.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAClG,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAU,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAOnE,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EACzC,MAAM,EAAE,CAAC,EACT,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAKxB;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EACzC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAM9B;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EACzC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAK9B;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,OAAO,EACzC,MAAM,EAAE,CAAC,EACT,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,cAAc,GACvB,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAK7B;AAED,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/docs/locale-packs.md

@@ -0,0 +1,78 @@
+# Work With Official Locale Packs and Registry Scoping
+
+Baobox preloads an official locale bundle for every declared locale code. Those bundles are exported through `baobox/locale` and registered into the default runtime context automatically.
+
+## What `baobox/locale` Exports
+
+`baobox/locale` exports:
+
+- A default `LocalePacks` object keyed by locale code
+- Named exports for every declared locale code such as `en_US`, `ko_KR`, `it_IT`, and `zh_Hant`
+- `OfficialLocaleCatalogs` for code that wants the full typed registry map
+
+That means these are equivalent:
+
+```ts
+import LocalePacks, { ko_KR } from 'baobox/locale'
+
+LocalePacks.ko_KR === ko_KR
+// true
+```
+
+## Use The Process-Default Registry
+
+The default runtime is already seeded with every declared locale bundle, so switching the active locale is enough for the common path.
+
+```ts
+import { Errors, String } from 'baobox'
+import { System } from 'baobox/system'
+
+System.Locale.Set(System.Locale.ko_KR)
+
+Errors(String(), 42)
+// [{ path: '/', code: 'INVALID_TYPE', message: 'string이어야 합니다. 현재 값 유형: number' }]
+```
+
+## Seed A Scoped Runtime Explicitly
+
+Import bundles from `baobox/locale` when you want an isolated runtime context with explicit locale registration.
+
+```ts
+import LocalePacks from 'baobox/locale'
+import { CreateRuntimeContext, Errors, LocaleCodes, String } from 'baobox'
+
+const context = CreateRuntimeContext({ localeCatalogs: [] })
+
+context.Locale.Register(LocaleCodes.it_IT, LocalePacks.it_IT)
+context.Locale.Set(LocaleCodes.it_IT)
+
+Errors(String(), 42, context)
+// [{ path: '/', code: 'INVALID_TYPE', message: 'Expected string, got number' }]
+```
+
+## Add A Project-Specific Catalog
+
+You can layer a custom locale on top of a shipped bundle.
+
+```ts
+import LocalePacks from 'baobox/locale'
+import { CreateRuntimeContext, Errors, String } from 'baobox'
+
+const context = CreateRuntimeContext({ localeCatalogs: [] })
+
+context.Locale.Register('en_TEST', {
+  ...LocalePacks.en_US,
+  INVALID_TYPE: () => 'yarrr-invalid-type',
+})
+context.Locale.Set('en_TEST')
+
+Errors(String(), 42, context)
+// [{ path: '/', code: 'INVALID_TYPE', message: 'yarrr-invalid-type' }]
+```
+
+## Translation Coverage
+
+- Every declared locale code has an official bundle, so declared codes do not fall back through the registry lookup path.
+- Native translated catalogs currently ship for `de_DE`, `en_US`, the Spanish family (`es_419`, `es_AR`, `es_ES`, `es_MX`), the French family (`fr_CA`, `fr_FR`), `ja_JP`, `ko_KR`, the Portuguese family (`pt_BR`, `pt_PT`), and both Chinese packs (`zh_Hans`, `zh_Hant`).
+- Remaining official bundles currently alias the English catalog until native translations are added.
+- Unknown locale identifiers still fall back to English unless you register them yourself.

package/docs/package-contract.md

@@ -0,0 +1,89 @@
+# Package Contract and Supported Imports
+
+This document describes the supported public import surface for baobox.
+
+## Resolution Behavior
+
+Baobox publishes export-condition entries in `package.json`.
+
+| Consumer | Resolution target |
+| --- | --- |
+| Bun | raw `src/*.ts` entrypoints through the `bun` condition |
+| Standard ESM | built `dist/*.js` entrypoints through the `import` condition |
+| TypeScript | generated `dist/*.d.ts` declarations through the `types` condition |
+
+That means Bun consumers can work directly against the source entrypoints without a prebuild, while published ESM consumers use the generated distribution files.
+
+The build writes JavaScript to `dist/index.js`, `dist/value/index.js`, and the matching subpath directories, so the emitted files and the export map stay in sync.
+
+## Supported Public Entrypoints
+
+These are the supported package imports:
+
+- `baobox`
+- `baobox/type`
+- `baobox/value`
+- `baobox/schema`
+- `baobox/error`
+- `baobox/compile`
+- `baobox/format`
+- `baobox/guard`
+- `baobox/system`
+- `baobox/script`
+- `baobox/locale`
+- `baobox/standard`
+
+## What Each Entrypoint Is For
+
+| Entrypoint | Purpose |
+| --- | --- |
+| `baobox` | Root TypeBox-style builders plus the common value and compile helpers |
+| `baobox/type` | Type builders, transforms, root helpers, and static type exports |
+| `baobox/value` | Runtime value operations such as `Check`, `Parse`, `Errors`, `Repair`, `Diff`, and `Patch` |
+| `baobox/schema` | Raw schema runtime helpers plus baobox schema emitter helpers |
+| `baobox/error` | Structured validation error surface |
+| `baobox/compile` | `Compile`, `Code`, and `Validator` |
+| `baobox/format` | Format registry and format helpers |
+| `baobox/guard` | Guard namespaces aligned with the TypeBox-style guard surface |
+| `baobox/system` | Runtime settings, locale, hashing, memory, and environment helpers |
+| `baobox/script` | Script DSL helpers |
+| `baobox/locale` | Official per-locale catalog bundles for the declared locale registry |
+| `baobox/standard` | Standard Schema V1 adapter helpers for typed and raw-schema interop |
+
+## Supported vs Internal Imports
+
+Supported:
+
+```ts
+import { Object, String } from 'baobox'
+import { Errors } from 'baobox/value'
+import { System } from 'baobox/system'
+```
+
+Internal to this repository:
+
+```ts
+import { Errors } from '../src/value/index.ts'
+```
+
+Direct `src/*` imports appear in this repository's tests because they validate the source tree before publishing. They are not part of the public package contract for consumers.
+
+## Root Import Expectations
+
+The root entrypoint supports both styles:
+
+```ts
+import Type from 'baobox'
+import { Object, String } from 'baobox'
+```
+
+The default namespace is convenient for builder-heavy code. Named imports are usually better when you want a small explicit surface.
+
+## `baobox/schema` Is Intentionally Split
+
+`baobox/schema` contains two related but distinct capabilities:
+
+- A raw `typebox/schema`-style runtime surface for checking, parsing, compiling, pointer access, and resolving raw schema objects.
+- The baobox schema emitter helpers that project baobox schemas to JSON-Schema-like output.
+
+That split is intentional. The raw schema runtime and the baobox emitter solve different problems, but they live behind the same subpath.

package/docs/parity-and-extensions.md

@@ -0,0 +1,56 @@
+# Parity Policy and Baobox-Only Additions
+
+Baobox aims for TypeBox compatibility without pretending to be a thin wrapper around upstream `typebox`.
+
+## Parity Rules
+
+Baobox maintains parity with two different expectations:
+
+1. Root exports are treated as an upstream-complete superset.
+2. The `compile`, `error`, `format`, `guard`, `system`, and `value` subpaths are runtime-parity tested against the installed `typebox` package.
+
+That means upstream-compatible code should keep working, while baobox can still publish Bun-first additions.
+
+## What "Superset" Means at Root
+
+The root entrypoint must continue to expose the upstream root helpers. Baobox-specific helpers are allowed to remain public as long as they do not break upstream-compatible usage.
+
+This is why root parity is tested as upstream-subset parity instead of exact key equality.
+
+## What Counts as a Baobox Addition
+
+Current baobox-specific improvements include:
+
+- Bun-first package exports through the `bun` condition
+- `TryParse()` and `Validator.TryParse()` for structured, non-throwing normalization results
+- `TryDecode()`, `TryEncode()`, `TryCreate()`, and `TryRepair()` for result-first codec and value workflows
+- `Explain()` for localized diagnostics that preserve raw issue metadata
+- `Uint8ArrayCodec()` for base64 JSON payloads and runtime byte values
+- `DateCodec()`, `URLCodec()`, and `BigIntCodec()` for common interop-heavy values
+- Bun-native binary fast paths inside `Compile()` for byte-oriented schemas
+- Compile caching plus portable validator artifacts
+- Locale-aware validation messages and registries driven from `baobox/system`
+- Official locale bundles for every declared locale code through `baobox/locale`
+- Standard Schema V1 adapters through `baobox/standard`
+
+These improvements extend the package, but they do not change the public `SchemaError` shape or the pass/fail semantics of validation.
+
+## Stability Expectations
+
+Baobox keeps the following compatibility boundaries stable:
+
+- `SchemaError` stays `{ path, message, code }`
+- `Parse(schema, value)` remains the throwing parity path; `TryParse(schema, value)` is the baobox-only extension
+- `System.Locale` remains the default-process configuration entry point for localized error messages
+- `CreateRuntimeContext()` scopes registries, locale catalogs, and compile caching without changing the default globals
+- Published consumers should only rely on package entrypoints, not `src/*`
+- Subpath parity tests remain the guardrail for TypeBox-aligned runtime behavior
+
+## `baobox/schema` Is Not a Wrapper Layer
+
+`baobox/schema` intentionally combines:
+
+- a raw `typebox/schema`-style runtime surface, and
+- baobox's schema emitter helpers
+
+That makes it broader than upstream's split without introducing a compatibility shim or bridge layer.

package/docs/script-module-registries.md

@@ -0,0 +1,107 @@
+# Use Script, Module, and Custom Registries
+
+Baobox keeps the TypeBox-style builder APIs, but it also supports a TypeScript-like DSL, named definition modules, and runtime registries for project-specific validation.
+
+## Script DSL
+
+Use `Script()` when the schema is easier to read as a compact type expression.
+
+```ts
+import { Check, Script } from 'baobox'
+
+const Users = Script('Array<{ name: string; age?: number }>')
+
+Check(Users, [{ name: 'Ada' }, { name: 'Grace', age: 37 }])
+// true
+```
+
+For reusable named definitions, use `ScriptWithDefinitions()`.
+
+```ts
+import { Check, Object, ScriptWithDefinitions, String } from 'baobox'
+
+const User = Object({ name: String() }, { required: ['name'] })
+const Users = ScriptWithDefinitions('Array<User>', { User })
+
+Check(Users, [{ name: 'Ada' }])
+// true
+```
+
+## Module and Import
+
+Use `Module()` when you want a small schema registry with named definitions, then resolve a concrete definition with `Import()`.
+
+```ts
+import { Check, Import, Module, Object, String } from 'baobox'
+
+const Models = Module({
+  User: Object({
+    id: String(),
+    name: String(),
+  }, { required: ['id', 'name'] }),
+})
+
+const User = Import(Models, 'User')
+
+Check(User, { id: 'usr_1', name: 'Ada' })
+// true
+```
+
+`module.Import(name)` returns a `Ref` schema. `Import(module, name)` returns the concrete definition directly.
+
+## FormatRegistry
+
+Use the format registry for new string formats.
+
+```ts
+import { Check, FormatRegistry, String } from 'baobox'
+
+FormatRegistry.Set('doc-slug', (value) => /^[a-z0-9-]+$/.test(value))
+
+const Slug = String({ format: 'doc-slug' })
+
+Check(Slug, 'docs-ready')
+// true
+```
+
+## TypeRegistry
+
+Use the type registry for custom `~kind` validators.
+
+```ts
+import { Check, TypeRegistry, type TSchema } from 'baobox'
+
+TypeRegistry.Set('PositiveNumber', (_schema, value) =>
+  typeof value === 'number' && value > 0
+)
+
+const PositiveNumber: TSchema = { '~kind': 'PositiveNumber' }
+
+Check(PositiveNumber, 3)
+// true
+```
+
+Registry notes:
+
+- Keep custom names stable. They become part of your schema contract.
+- Clean up temporary test-only registrations with `Delete()`.
+- `TypeRegistry` affects runtime validation. It does not add JSON Schema emission automatically.
+
+## Codec
+
+Use `Codec()` when you want typed decode and encode transforms without writing callback casts.
+
+```ts
+import { Codec, String } from 'baobox'
+import { Decode, Encode } from 'baobox/value'
+
+const Trimmed = Codec(String())
+  .Decode((value) => value.trim())
+  .Encode((value) => value.toUpperCase())
+
+Decode(Trimmed, '  ada  ')
+// "ada"
+
+Encode(Trimmed, 'ada')
+// "ADA"
+```

package/docs/workflows.md

@@ -0,0 +1,154 @@
+# Choose Check vs TryParse vs Parse vs Compile
+
+Baobox exposes a result-first runtime family around the familiar TypeBox-style surface. The workflows share the same schema model, but they answer different questions.
+
+| Need | API | Returns | Use when |
+| --- | --- | --- | --- |
+| Boolean validation | `Check(schema, value)` | `boolean` | You only need pass or fail |
+| Normalize without exceptions | `TryParse(schema, value)` | `ParseResult<T>` | You want normalized output and structured errors without throwing |
+| Codec decode without exceptions | `TryDecode(schema, value)` | `ParseResult<T>` | You want decoded output and structured failures |
+| Codec encode without exceptions | `TryEncode(schema, value)` | `ParseResult<T>` | You want encoded output without throw-based control flow |
+| Create defaults without exceptions | `TryCreate(schema)` | `ParseResult<T>` | You want generated defaults plus validation evidence |
+| Repair without exceptions | `TryRepair(schema, value)` | `ParseResult<T>` | You want a corrected value and structured failures |
+| Normalize then validate | `Parse(schema, value)` | normalized value or throws `ParseError` | You want defaults, conversions, and cleanup before validation |
+| Explain failures with diagnostics | `Explain(schema, value)` | diagnostics array | You want raw issue codes, params, locale, and message |
+| Reusable hot-path validator | `Compile(schema)` / `CompileCached(schema)` | `Validator` | You will validate the same schema repeatedly |
+
+## Check
+
+Use `Check` when you want the lowest-friction runtime guard.
+
+```ts
+import { Check, Object, String } from 'baobox'
+
+const User = Object({
+  id: String(),
+  name: String(),
+}, { required: ['id', 'name'] })
+
+Check(User, { id: 'usr_1', name: 'Ada' })
+// true
+```
+
+## TryParse
+
+`TryParse` runs the full value pipeline in this order:
+
+1. `Clone`
+2. `Default`
+3. `Convert`
+4. `Clean`
+5. `Check`
+
+Use it when the caller wants normalized output and structured errors without exception control flow.
+
+```ts
+import { Number, Object, TryParse } from 'baobox'
+
+const Counter = Object({
+  count: Number(),
+}, { required: ['count'], additionalProperties: false })
+
+TryParse(Counter, { count: '5', extra: true })
+// { success: true, value: { count: 5 } }
+```
+
+## Parse
+
+`Parse` runs the full value pipeline in this order:
+
+1. `Clone`
+2. `Default`
+3. `Convert`
+4. `Clean`
+5. `Check`
+
+That makes it the right choice for request payloads and config-like inputs.
+
+```ts
+import { Object, Number, Optional, Parse, String } from 'baobox'
+
+const Counter = Object({
+  count: Number(),
+  label: Optional(String()),
+}, {
+  required: ['count'],
+  optional: ['label'],
+  additionalProperties: false,
+})
+
+Parse(Counter, { count: '5', extra: true })
+// { count: 5 }
+```
+
+If the normalized value still fails validation, `Parse` throws `ParseError`. This preserves the upstream TypeBox-style contract. Prefer `TryParse` when the caller wants a non-throwing path.
+
+## Compile
+
+`Compile` is the reusable path. It creates a validator once and then exposes the common runtime helpers off that compiled instance.
+
+```ts
+import { CompileCached, Number, Object } from 'baobox'
+
+const validator = CompileCached(Object({
+  count: Number({ minimum: 1 }),
+}, { required: ['count'] }))
+
+validator.Check({ count: 2 })
+// true
+
+validator.TryParse({ count: '2' })
+// { success: true, value: { count: 2 } }
+
+validator.Errors({ count: 0 })
+// [{ path: 'count', code: 'MINIMUM', message: 'Value must be >= 1' }]
+```
+
+Compiled validators now support:
+
+- Per-runtime-context cache reuse.
+- Portable `validator.Artifact()` output.
+- Artifact reloading through `CompileFromArtifact(schema, artifact)`.
+- The same result-first helpers as the root API: `TryDecode`, `TryEncode`, `TryCreate`, `TryParse`, and `TryRepair`.
+
+## Explain
+
+`Explain` preserves the raw issue metadata while still localizing the final message.
+
+```ts
+import { Explain, String } from 'baobox'
+
+Explain(String(), 42)
+// [{
+//   path: '/',
+//   code: 'INVALID_TYPE',
+//   params: { expected: 'string', actual: 'number' },
+//   locale: 'en_US',
+//   message: 'Expected string, got number'
+// }]
+```
+
+## Localized Errors
+
+Both `Value.Errors()` and `Compile(schema).Errors()` read the active locale from `baobox/system`.
+
+```ts
+import { Errors, String } from 'baobox'
+import { System } from 'baobox/system'
+
+System.Locale.Set(System.Locale.ko_KR)
+
+Errors(String(), 42)
+// [{ path: '/', code: 'INVALID_TYPE', message: 'string이어야 합니다. 현재 값 유형: number' }]
+```
+
+Current behavior:
+
+- `en_US` is the default locale.
+- Every declared locale code now has an official bundle through `baobox/locale`, so declared locales resolve directly from the registry.
+- Native translated catalogs currently ship for `de_DE`, `en_US`, the Spanish family (`es_419`, `es_AR`, `es_ES`, `es_MX`), the French family (`fr_CA`, `fr_FR`), `ja_JP`, `ko_KR`, the Portuguese family (`pt_BR`, `pt_PT`), and both Chinese packs (`zh_Hans`, `zh_Hant`).
+- Remaining official bundles currently alias the English catalog until native translations are added.
+
+You can scope locale, registry, and compile-cache behavior with `CreateRuntimeContext()` and pass that context into `Check`, `Parse`, `TryParse`, and `Compile`.
+
+For explicit bundle imports and scoped registration examples, see [Work with official locale packs and registry scoping](./locale-packs.md).