# Slovo

Slovo (ⰔⰎⰑⰂⰑ) is a typed structural programming language and toolchain.

This repository is the canonical public monorepo for the language design,
standard library source, compiler, runtime, examples, benchmarks, and technical
documents.

Current release: `1.0.0-beta.25`.

## Repository Layout

```text
compiler/       Glagol, the first Slovo compiler
runtime/        C runtime used by hosted native builds
lib/std/        source-authored Slovo standard-library facades
examples/       compiler-supported Slovo examples and projects
benchmarks/     local benchmark comparison harnesses
docs/language/  language manifest, specs, roadmap, and release notes
docs/compiler/  compiler manifest, roadmap, and release notes
docs/papers/    whitepapers and generated publication PDFs
scripts/        local release and document tooling
```

## Beta Scope

`1.0.0-beta.25` keeps the `1.0.0-beta` language baseline, includes the
`1.0.0-beta.1` tooling/install hardening slice, the `1.0.0-beta.2`
runtime/resource foundation bundle, the `1.0.0-beta.3` standard-library
stabilization bundle, the `1.0.0-beta.4` language-usability diagnostics
bundle, the `1.0.0-beta.5` local package/workspace discipline bundle, and the
`1.0.0-beta.6` loopback networking foundation, plus the `1.0.0-beta.7`
serialization/data-interchange foundation and the `1.0.0-beta.8` concrete type
alias foundation, the `1.0.0-beta.9` collection alias unification and
generic reservation slice, the `1.0.0-beta.10` developer-experience API
discovery slice, and the `1.0.0-beta.11` local package API documentation
slice, plus the `1.0.0-beta.12` concrete vector query and prefix parity
slice, the `1.0.0-beta.13` diagnostic catalog and schema policy slice, the
`1.0.0-beta.14` benchmark suite catalog and metadata gate, and the
`1.0.0-beta.15` reserved generic collection boundary hardening and collection
ledger, the `1.0.0-beta.16` string scanning and token boundary foundation,
the `1.0.0-beta.17` JSON primitive scalar parsing foundation, the
`1.0.0-beta.18` JSON string token parsing foundation, the
`1.0.0-beta.19` test discovery and user-project conformance foundation, the
`1.0.0-beta.20` string search and ASCII trim foundation, and the
`1.0.0-beta.21` JSON document scalar parsing foundation, plus the
`1.0.0-beta.22` run manifest and execution report hardening slice, and the
`1.0.0-beta.23` standard-library stability tier ledger and catalog alignment
slice, and the `1.0.0-beta.24` package manifest identity and local dependency
diagnostic hardening slice, plus the `1.0.0-beta.25` user-project
conformance matrix evidence slice.

The language baseline supports practical local command-line, file, and
loopback-network programs with:

- modules, explicit imports, packages, and local workspaces
- `new`, `check`, `fmt`, `test`, `doc`, `symbols`, `build`, `run`, and
  `clean`
- `i32`, `i64`, `u32`, `u64`, `f64`, `bool`, `string`, and internal `unit`
- structs, enums, fixed arrays, concrete vectors, option/result families, and
  current `match`
- module-local transparent concrete type aliases
- explicit `std/*.slo` imports from `lib/std`, installed `share/slovo/std`, or
  `SLOVO_STD_PATH`
- beta-scoped loopback TCP handles through `std.net`
- JSON string quoting, compact JSON text construction, primitive scalar token
  parsing, ASCII JSON string-token parsing, and scalar JSON document parsing
  through `std.json`
- byte-oriented string search and ASCII edge trimming through `std.string`
- hosted native builds through LLVM IR, Clang, and `runtime/runtime.c`

The generated standard-library API catalog is a beta discovery aid: it lists
exported helper signatures from `lib/std/*.slo`, normalizes module-local
concrete aliases such as `VecI32` and `ResultU64` to their concrete public
types, and omits non-exported helpers and `(type ...)` aliases.
The companion
[`docs/language/STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) ledger
defines the public tier labels `beta-supported`, `experimental`, and
`internal`, marks JSON, loopback networking, random/time, and filesystem
resource-handle helpers as experimental domains, and keeps concrete vector
modules as beta-supported concrete lanes rather than a generic collections
freeze.
`glagol symbols <file.slo|project|workspace>` emits deterministic
editor-facing S-expression metadata for modules, imports, exports, aliases,
structs, enums, functions, tests, source spans, and workspace package names.
`glagol doc <file|project|workspace> -o <dir>` now includes deterministic public
API sections for local package and module documentation: exact exported
function signatures, exported struct fields, exported enum variants and payload
types, non-export filtering, and module-local alias normalization.
The `1.0.0-beta.22` tooling slice adds an additive run-report block to
`glagol run --manifest` artifact manifests so local evidence can record the
program exit status, captured stdout, captured stderr, and forwarded program
arguments. This is beta CLI evidence hardening only: it does not add language
or stdlib features and does not freeze the artifact-manifest schema.
The `1.0.0-beta.12` vector parity slice adds source-authored helper coverage
only: `std.vec_i64` gains `count_of`, `starts_with`, `without_prefix`,
`ends_with`, and `without_suffix`, while `std.vec_f64` gains `count_of`.
The `1.0.0-beta.13` diagnostics slice documents the beta
`slovo.diagnostic` version `1` policy in
[`docs/language/DIAGNOSTICS.md`](docs/language/DIAGNOSTICS.md): the
S-expression/JSON relationship, required and optional fields, JSON-line
discipline, source-less diagnostics, manifest diagnostic metadata,
compatibility and migration classes, and the current golden diagnostic code
catalog.
The `1.0.0-beta.14` benchmark metadata slice documents the existing benchmark
suite catalog in [`benchmarks/README.md`](benchmarks/README.md). It explains
`python3 benchmarks/runner.py --suite-list` for the human-readable suite
inventory and `python3 benchmarks/runner.py --suite-list --json` for beta
tooling metadata, with required scaffold-file verification for each current
suite. Benchmark timings remain local-machine evidence only; the JSON field
set is not a stable public schema.
The `1.0.0-beta.15` collection ledger and reserved diagnostic hardening slice
adds
[`docs/language/COLLECTIONS.md`](docs/language/COLLECTIONS.md) as the
docs/design ledger for current concrete collection and value-family
boundaries. It links to the generated
[`docs/language/STDLIB_API.md`](docs/language/STDLIB_API.md) catalog for exact
public helper signatures, records design pressure from duplicated concrete
vector/option/result families, defines prerequisites before executable
generics, generic aliases, maps, sets, iterators, mutable vectors, or
slice/view APIs can be promoted, and treats current unsupported diagnostics as
boundaries. It rewords affected reserved-boundary diagnostics from
beta.9-specific text to current-beta wording while preserving diagnostic
codes, schema, spans, expected/found values, hints, and output shape. It
changes no source language, runtime, stdlib/API surface, benchmark metadata
schema, ABI/layout behavior, or performance claim.
The `1.0.0-beta.16` string scanning and token boundary foundation adds
source facades and explicit examples for `std.string.byte_at_result`,
`std.string.slice_result`, `std.string.starts_with`, and
`std.string.ends_with`. These helpers are byte-oriented over the current
NUL-terminated runtime string representation; invalid indexes and ranges return
`err 1`, and substring allocation failure follows the existing string
allocation trap policy. This release does not promise Unicode scalar,
grapheme, display-width, or locale semantics; does not add full JSON parsing,
object/array parsing, tokenizers, a language slice/view feature, or a stable
stdlib/API freeze.

The `1.0.0-beta.17` JSON primitive scalar parsing foundation adds
result-returning `std.json.parse_*_value_result` helpers for booleans,
concrete numeric primitives, and exact `null` only. Numeric and boolean parse
helpers consume one isolated JSON primitive token: no leading/trailing
whitespace, no leading `+`, no leading-zero integer form except `0`, and no
non-finite f64 values. This is not full JSON parsing: object/array parsing,
tokenizers, recursive `JsonValue`, document parsing beyond the beta21 scalar
document helpers, schema validation, streaming, Unicode escape handling,
stable ABI/layout, and a stable stdlib/API freeze remain deferred.

The `1.0.0-beta.18` JSON string token parsing foundation adds
`std.json.parse_string_value_result` as a thin source facade over the matching
promoted runtime name. It consumes one already-isolated ASCII JSON string token
with exact quotes and no leading/trailing whitespace, decodes the simple JSON
escapes `\"`, `\\`, `\/`, `\b`, `\f`, `\n`, `\r`, and `\t`, and returns
`err 1` for ordinary parse failure. Complete JSON document parsing beyond the
beta21 scalar document helpers, object/array parsing, tokenizer APIs, Unicode
escape decoding/normalization, embedded NUL policy, stable ABI/layout, and a
stable stdlib/API freeze remain deferred.

The `1.0.0-beta.19` test discovery and user-project conformance foundation
adds `glagol test --list <file|project|workspace>` plus legacy
`glagol --run-tests --list <file>` support for listing checked and discovered
tests without executing test bodies. The list mode preserves existing file,
project, and workspace test ordering, honors `--filter <substring>`, and
remains beta tooling rather than a stable output schema.

The `1.0.0-beta.20` string search and ASCII trim foundation adds
`std.string.contains`, `std.string.index_of_option`,
`std.string.last_index_of_option`, `std.string.trim_ascii_start`,
`std.string.trim_ascii_end`, and `std.string.trim_ascii` as ordinary source
helpers over the existing byte string primitives. Search is byte-oriented,
empty needles match at the first index and at `(len value)` for last search,
and ASCII trimming removes only bytes `9`, `10`, `11`, `12`, `13`, and `32`.

The `1.0.0-beta.21` JSON document scalar parsing foundation adds
source-authored `std.json.parse_*_document_result` helpers for string, bool,
`i32`, `u32`, `i64`, `u64`, `f64`, and exact `null` scalar JSON documents.
Each helper trims ASCII whitespace around the whole document with
`std.string.trim_ascii`, then delegates to the already released exact JSON
value-token parser for that scalar family. This scope does not add new
compiler-known runtime names, object/array parsing, recursive `JsonValue`,
tokenizer objects, maps/sets, streaming, Unicode escape decoding beyond the
existing string-token behavior, embedded NUL policy, stable ABI/layout, or a
stable stdlib/API freeze.

The `1.0.0-beta.22` run manifest and execution report hardening slice extends
`glagol run --manifest` artifact manifests with additive run-report evidence:
the executed program's exit status, captured stdout, captured stderr, and
forwarded user-program arguments. This release does not add source-language
syntax, standard-library helpers, compiler-known runtime names, runtime
capabilities, package behavior, stable artifact-manifest schema guarantees,
stable ABI/layout, or a stable stdlib/API freeze.

The `1.0.0-beta.23` standard-library stability tier ledger and catalog
alignment slice adds the public
[`STDLIB_TIERS.md`](docs/language/STDLIB_TIERS.md) maturity ledger beside the
generated [`STDLIB_API.md`](docs/language/STDLIB_API.md) signature catalog.
It is documentation/catalog tooling clarity only: no source-language syntax,
stdlib helpers, compiler-known runtime names, runtime behavior, stable manifest
schema, stable Markdown schema, stable ABI/layout, or stable stdlib/API freeze
changes. The generated catalog and release gate now expose and check tier
metadata.

The `1.0.0-beta.24` package manifest identity and local dependency discipline
slice tightens local manifest diagnostics only: duplicate package manifest
keys, invalid dependency keys, and duplicate dependency keys are explicit beta
package/workspace diagnostics. It does not add remote registries, lockfiles,
semantic-version solving, package publishing, optional/dev/target
dependencies, stable package ABI/layout, source-language changes, runtime
changes, or standard-library changes.

The `1.0.0-beta.25` user-project conformance matrix slice adds deterministic
tooling/readiness evidence over the existing `examples/projects/` and
`examples/workspaces/` inventories. It currently covers all 43 top-level
fixture roots and 655 discovered tests through ordinary `check`,
`test --list`, and stable `test` entry points. The matrix is for ordinary
project and workspace usage evidence only: it does not add source-language
syntax or semantics, standard-library helpers, runtime behavior, package
manager or registry behavior, lockfile behavior, semantic-version solving,
stable schema guarantees, or performance claims.

Still deferred before stable: executable generics, generic aliases, maps/sets,
broad package registry semantics, stable artifact-manifest schema, stable
Markdown schema, stable conformance-matrix schema, stable stdlib/API
compatibility freeze, DNS/TLS/async networking, LSP/watch guarantees, SARIF
and daemon protocols, stable `1.0.0`
diagnostics freeze,
re-exports/globs/hierarchical modules, mutable vectors, slice/view APIs,
iterators, additional compiler-known runtime names, stable ABI and layout,
performance claims, stable benchmark JSON metadata schema, and runtime changes
for generic collections.

The beta19 tooling scope is deliberately tooling-only. It does not add parallel
test execution, retries, tags/groups, coverage reports, event streams, stable
manifest or Markdown schema guarantees, LSP/watch behavior, SARIF/daemon
protocols, JSON expansion, runtime helper names, source-language syntax,
remote package registries, semver solving, or performance claims.

## Build And Test

```bash
cargo test --manifest-path compiler/Cargo.toml
```

Run the full local release gate:

```bash
./scripts/release-gate.sh
```

Build the compiler binary:

```bash
cargo build --manifest-path compiler/Cargo.toml
./compiler/target/debug/glagol --version
```

Create and check a project:

```bash
./compiler/target/debug/glagol new hello
SLOVO_STD_PATH="$PWD/lib/std" ./compiler/target/debug/glagol check hello
SLOVO_STD_PATH="$PWD/lib/std" ./compiler/target/debug/glagol test hello
```

Build a native executable when Clang is available:

```bash
SLOVO_STD_PATH="$PWD/lib/std" ./compiler/target/debug/glagol build hello -o hello/bin
```

## 1.0.0-beta.1 Tooling Additions

The `1.0.0-beta.1` release improves the common local development and install
loop without adding new source-language syntax.

Build and execute in one step:

```bash
SLOVO_STD_PATH="$PWD/lib/std" ./compiler/target/debug/glagol run hello
SLOVO_STD_PATH="$PWD/lib/std" ./compiler/target/debug/glagol clean hello
```

Create alternate project shapes:

```bash
./compiler/target/debug/glagol new numbers --template library
./compiler/target/debug/glagol new workspace-demo --template workspace
```

Install the current checkout:

```bash
PREFIX="$HOME/.local" ./scripts/install.sh
```

The installed layout is:

```text
<prefix>/bin/glagol
<prefix>/share/slovo/std/*.slo
<prefix>/share/slovo/runtime/runtime.c
```

Installed `glagol` discovers `share/slovo/std` and
`share/slovo/runtime/runtime.c` relative to its executable. `SLOVO_STD_PATH`
can still override standard-library search, `SLOVO_RUNTIME_C` or
`GLAGOL_RUNTIME_C` can override the runtime C input, and `GLAGOL_CLANG` can
select the Clang-compatible compiler.

## 1.0.0-beta.2 Runtime Resource Foundation

The `1.0.0-beta.2` release adds beta-scoped runtime/resource foundation work:

- `std.fs.open_text_read_result`
- `std.fs.read_open_text_result`
- `std.fs.close_result`
- `std.fs.exists`
- `std.fs.is_file`
- `std.fs.is_dir`
- `std.fs.remove_file_result`
- `std.fs.create_dir_result`
- matching explicit `lib/std/fs.slo` facades

These APIs use beta-scoped opaque `i32` file handles. They do not claim stable
file descriptors, writable streams, binary IO, directory handles, sockets,
async IO, platform error codes, or stable handle ABI/layout. Directory creation
is intentionally narrow and does not imply directory enumeration or recursive
filesystem APIs.

## 1.0.0-beta.3 Standard Library Stabilization

The `1.0.0-beta.3` release starts the standard-library stabilization slice. It
adds a generated standard-library API catalog and
`examples/projects/stdlib-composition`, a checked/tested/run-capable program
that composes `std.fs`, `std.string`, `std.math`, and `std.io`.

## 1.0.0-beta.4 Language Usability Diagnostics

The `1.0.0-beta.4` release improves diagnostics without changing the source
language surface. Project/workspace build and run entry failures now use
entry-specific diagnostic codes, and non-exhaustive `match` diagnostics have
clearer wording with deterministic found-arm output.

## 1.0.0-beta.5 Package And Workspace Discipline

The `1.0.0-beta.5` release tightens local package/workspace behavior. Local
workspaces may declare `[workspace] default_package = "name"` to select the
build/run entry package when multiple packages have entry modules. Duplicate
normalized workspace members and missing default-package references are now
dedicated diagnostics. `glagol doc <workspace> -o <dir>` includes a workspace
package/dependency summary, new workspace templates declare
`default_package = "app"`, and `docs/language/PACKAGES.md` documents the beta
local-package rules. Remote registries, lockfiles, semantic-version solving,
package publishing, and stable package ABI/layout remain deferred.

## 1.0.0-beta.24 Package Manifest Identity And Dependency Discipline

The `1.0.0-beta.24` release keeps the local package model closed and local. It
hardens diagnostics for manifest identity/dependency mistakes only: duplicate
package manifest keys, invalid dependency keys, and duplicate dependency keys
are reported explicitly.

This scope does not add a remote registry, lockfile, semantic-version solver,
package publishing flow, optional/dev/target dependencies, stable package
ABI/layout, source-language behavior, runtime behavior, or standard-library
behavior.

## 1.0.0-beta.25 User Project Conformance Matrix

The `1.0.0-beta.25` release adds deterministic tooling evidence for the
existing user-shaped examples under `examples/projects/` and
`examples/workspaces/`. The conformance matrix is sorted by repository path and
records ordinary `check`, `test --list`, and stable `test` behavior for all
43 top-level fixture roots and 655 discovered tests.

This scope is stable-readiness evidence only. It adds no source-language
change, standard-library helper change, runtime behavior change, package
manager or registry behavior, lockfile behavior, semantic-version solving,
stable schema freeze, or performance claim.

## 1.0.0-beta.6 Networking Foundation

The `1.0.0-beta.6` release adds a narrow blocking loopback TCP foundation:

- compiler-known `std.net.tcp_*_result` calls for connect, listen,
  bound-port lookup, accept, read-all, write-text, and close
- `lib/std/net.slo` source facades and explicit std/local example projects
- opaque beta-scoped `i32` socket handles with concrete `result` values

This is not a general networking stack. DNS, TLS, UDP, non-loopback binding,
async IO, HTTP frameworks, rich host-error ADTs, stable socket ABI/layout, and
automatic resource ownership remain deferred.

## 1.0.0-beta.7 Serialization And Data Interchange

The `1.0.0-beta.7` release adds a narrow JSON text-construction foundation:

- compiler-known `std.json.quote_string` for deterministic compact JSON string
  quoting
- `lib/std/json.slo` source helpers for scalar values, fields, small arrays,
  and small objects
- explicit std/local JSON example projects and a `json-quote-loop` benchmark
  scaffold

This is not a complete JSON library. Full parsing beyond primitive scalar
tokens and the ASCII JSON string-token helper, object/array parsing,
recursive JSON values, maps/sets, streaming encoders or decoders, schema
validation, Unicode normalization, and a stable data-interchange API freeze
remain deferred.

## 1.0.0-beta.8 Concrete Type Alias Foundation

The `1.0.0-beta.8` release adds transparent concrete type aliases:

```slo
(type JsonText string)
```

Aliases are module-local names for already supported concrete target types.
They may appear in local signatures and annotations, but they do not create new
runtime representations or stable ABI names. Project imports of functions that
use aliases see the resolved concrete target type. Alias exports, imports,
re-exports, generic aliases, parameterized aliases, maps/sets, and new
compiler-known runtime names remain out of scope.

## 1.0.0-beta.9 Collection Alias Unification And Generic Reservation

The `1.0.0-beta.9` release applies beta.8 concrete aliases inside the current
source-authored collection/value-family facades. The public helper names and
runtime behavior remain concrete: current vectors, options, and results are
still concrete families, and the local aliases are erased before lowering.

This release also reserves the generic/map/set direction through diagnostics
and documentation only. It does not implement executable generics, maps, sets,
traits, inference, monomorphization, iterators, stable ABI/layout promises, or
a stable standard-library API freeze.

## 1.0.0-beta.10 Developer Experience API Discovery

The `1.0.0-beta.10` release upgrades the generated standard-library API
catalog from exported helper names to exact exported helper signatures. The
renderer verifies that every exported helper has a matching `(fn ...)` form,
normalizes module-local concrete aliases from the public signatures, omits
non-exported helpers and `(type ...)` aliases, and keeps the catalog generated
from `lib/std/*.slo`.

It also adds `glagol symbols <file.slo|project|workspace>` as an
editor-facing metadata command. The output is deterministic S-expression text
using `slovo.symbols` schema version `1.0.0-beta.10`; it includes module paths,
source spans/ranges, imports, exports, aliases, structs, enums, functions,
tests, and workspace package labels.

This release is tooling, documentation, and API-discovery work. It does not
add executable generics, maps, sets, new runtime helpers, new compiler-known
runtime names, ABI/layout guarantees, an LSP server, watch mode, or a stable
standard-library API freeze.

## 1.0.0-beta.11 Local Package API Documentation

The `1.0.0-beta.11` release extends the beta.10 API discovery lane to local
package and module documentation. `glagol doc <file|project|workspace> -o <dir>`
includes deterministic exported/public API sections for local modules and
workspace packages.

Those sections list exact exported function signatures, exported struct fields,
and exported enum variants with payload types. They omit non-exported
functions, structs, enums, tests, and aliases from the public API surface, and
they normalize module-local concrete aliases before rendering public types.

This remains beta API discovery. It does not freeze the Markdown schema, create
a stable stdlib/API compatibility freeze, add LSP/watch behavior, define
SARIF or daemon protocols, set diagnostics schema policy, implement executable
generics, maps, or sets, add re-exports, globs, or hierarchical modules, or
define package registry semantics.

## 1.0.0-beta.12 Concrete Vector Query And Prefix Parity

The `1.0.0-beta.12` release is a source-authored stdlib/helper parity update
for concrete vectors. It adds `count_of`, `starts_with`, `without_prefix`,
`ends_with`, and `without_suffix` to `std.vec_i64`, and adds `count_of` to
`std.vec_f64`, matching the already staged concrete helper style.

This release does not change the source language, runtime, compiler-known
`std.vec.*` names, ABI/layout contract, or performance contract. Generics,
maps/sets, iterators, mutable vectors, slice/view APIs, new runtime helper
names, stable stdlib API freeze, and broader collection abstractions remain
deferred.

## 1.0.0-beta.13 Diagnostic Catalog And Schema Policy

The `1.0.0-beta.13` release is a docs/tooling policy update for the existing
diagnostic surface. It adds
[`docs/language/DIAGNOSTICS.md`](docs/language/DIAGNOSTICS.md) as the beta
policy for `slovo.diagnostic` version `1`.

The policy documents the S-expression and JSON encodings, required and optional
machine fields, severity/source/range/related-span semantics, JSON-line
discipline, source-less diagnostics, artifact-manifest diagnostic metadata,
compatibility and migration classes, and the current code catalog covered by
the golden diagnostics contract.

This release does not change the source language, runtime, stdlib API,
diagnostic output shape, compiler CLI, LSP/watch behavior, SARIF/daemon
protocols, stable Markdown schema, or stable `1.0.0` diagnostics freeze.

## 1.0.0-beta.16 String Scanning And Token Boundary Foundation

The `1.0.0-beta.16` release adds the first explicit byte-oriented string
scanning and token-boundary helpers to the `std.string` source facade:
`byte_at_result`, `slice_result`, `starts_with`, and `ends_with`.

The helpers operate over the current NUL-terminated runtime string bytes before
the trailing NUL. `byte_at_result` and `slice_result` return `err 1` for
ordinary invalid indexes or ranges. `slice_result` returns a runtime-owned
string on success; allocation failure may trap with the existing string
allocation policy.

This release does not add Unicode scalar, grapheme, display-width, or locale
semantics; full JSON parsing; object/array parsing; tokenizer APIs; a language
slice/view feature; mutable strings; stable ABI/layout; or a stable stdlib/API
freeze.

## 1.0.0-beta.20 String Search And ASCII Trim Foundation

The `1.0.0-beta.20` scope extends the source-authored `std.string` facade
with byte-oriented search and ASCII trim helpers:
`contains`, `index_of_option`, `last_index_of_option`, `trim_ascii_start`,
`trim_ascii_end`, and `trim_ascii`.

This scope adds no compiler-known runtime names. It does not claim Unicode
scalar, grapheme, case-folding, locale, regex, tokenizer, mutable string,
language slice/view, stable ABI/layout, or stable stdlib/API semantics.

## 1.0.0-beta.21 JSON Document Scalar Parsing Foundation

The `1.0.0-beta.21` scope extends `std.json` with source-authored
whole-document scalar helpers:
`parse_string_document_result`, `parse_bool_document_result`,
`parse_i32_document_result`, `parse_u32_document_result`,
`parse_i64_document_result`, `parse_u64_document_result`,
`parse_f64_document_result`, and `parse_null_document_result`.

The helpers accept leading and trailing ASCII whitespace around a single
scalar document by composing with `std.string.trim_ascii`; trailing
non-whitespace still fails through the existing exact value-token parsers.

This scope does not add object/array parsing, recursive JSON values, parser
objects, maps/sets, streaming, Unicode escape decoding beyond the existing
string-token behavior, embedded NUL policy, new compiler-known runtime names,
stable ABI/layout, or stable stdlib/API semantics.

## 1.0.0-beta.22 Run Manifest And Execution Report Hardening

The `1.0.0-beta.22` scope hardens `glagol run --manifest` evidence by adding
an additive run-report block to run-mode artifact manifests. The block records
the executed program's exit status, captured stdout, captured stderr, and
forwarded program arguments.

This is tooling/CLI evidence work only. It does not add language syntax,
stdlib helpers, compiler-known runtime names, runtime C capabilities, package
or import behavior, stable artifact-manifest schema guarantees, stable
ABI/layout, or stable stdlib/API semantics.

## 1.0.0-beta.15 Reserved Generic Collection Boundary Hardening And Collection Ledger

The `1.0.0-beta.15` release documents the current concrete collection and
value-family boundary. It adds
[`docs/language/COLLECTIONS.md`](docs/language/COLLECTIONS.md), which links to
the generated
[`docs/language/STDLIB_API.md`](docs/language/STDLIB_API.md) catalog instead
of duplicating generated helper counts.

The ledger inventories concrete vector, option, result, and related
option/result-returning facade surfaces; records the design pressure from
duplicated concrete vector/option/result helpers; and defines prerequisites
before executable generics, generic aliases, maps, sets, iterators, mutable
vectors, or slice/view APIs can be promoted.

Current unsupported diagnostics are documented as release boundaries, not as
new behavior. This release does not change the source language, runtime,
stdlib/API surface, diagnostic output shape/codes/schema, benchmark metadata
schema, compiler ABI/layout behavior, or performance claims, and it does not
create a stable stdlib/API freeze. It does reword affected reserved-boundary
diagnostic messages from beta.9-specific text to current-beta wording while
preserving diagnostic codes, schema, spans, expected/found values, hints, and
output shape.

## 1.0.0-beta.14 Benchmark Suite Catalog And Metadata Gate

The `1.0.0-beta.14` release documents the existing benchmark suite catalog as
beta-scoped metadata tooling. It adds
[`benchmarks/README.md`](benchmarks/README.md) with the current ten-suite
inventory, local evidence policy, suite-list commands, and exclusions.

The root suite catalog commands are:

```bash
python3 benchmarks/runner.py --suite-list
python3 benchmarks/runner.py --suite-list --json
```

The non-JSON listing is for local review. The JSON listing is beta tooling
metadata for local gates and adapters, not a stable public schema.

This release does not add benchmark kernels, publish timing numbers, define
performance thresholds, change the source language, runtime, stdlib/API
surface, diagnostic output, compiler ABI/layout behavior, or make cross-machine
performance claims.

## Documentation

- [Language Manifest](docs/language/MANIFEST.md)
- [Language Specification](docs/language/SPEC-v1.md)
- [Diagnostics Policy](docs/language/DIAGNOSTICS.md)
- [Local Package And Workspace Guide](docs/language/PACKAGES.md)
- [Standard Library API Catalog](docs/language/STDLIB_API.md)
- [Collection Ledger](docs/language/COLLECTIONS.md)
- [Benchmark Suite Catalog](benchmarks/README.md)
- [Compiler Manifest](docs/compiler/GLAGOL_COMPILER_MANIFEST.md)
- [Post-Beta Roadmap](docs/POST_BETA_ROADMAP.md)
- [Slovo Whitepaper](docs/papers/SLOVO_WHITEPAPER.md)
- [Glagol Whitepaper](docs/papers/GLAGOL_WHITEPAPER.md)

Generated PDFs live beside their Markdown sources in `docs/papers/`.
Regenerate them with `./scripts/render-doc-pdfs.sh` before documentation
releases.

## License

Slovo is licensed under either the MIT License or the Apache License, Version
2.0, at your option.