slovo/docs/compiler/RELEASE_NOTES.md

# Glagol Release Notes

## Release Maturity Policy

Historical `exp-*` releases listed here are experimental maturity milestones.
`1.0.0-beta` is the first real general-purpose beta release.

The pushed tag `v2.0.0-beta.1` is historical. It remains an experimental
integration/readiness release, not the first real beta.

## Unreleased

- Project build/run entry diagnostics now use entry-specific codes:
  `ProjectEntryMainMissing`, `ProjectEntryMainInvalidSignature`,
  `WorkspaceEntryMainMissing`, and `WorkspaceEntryMainInvalidSignature`.
  Messages now spell out the required `(fn main () -> i32 ...)` contract and
  include the found parameter count and return type for invalid signatures.
- Non-exhaustive `match` diagnostics now use clearer missing-arm wording and a
  deterministic found-arm list.

## 1.0.0-beta.3

Release label: `1.0.0-beta.3`

Release date: 2026-05-22

Release state: standard-library stabilization beta update

### Summary

Glagol `1.0.0-beta.3` keeps the `1.0.0-beta` compiler support baseline and
adds the first standard-library stabilization bundle:

- `scripts/render-stdlib-api-doc.sh` generates
  `docs/language/STDLIB_API.md` from repo-root `lib/std/*.slo`
- the release gate now verifies that generated standard-library API catalog
  before tests and smoke checks complete
- `examples/projects/stdlib-composition` proves a realistic multi-module
  standard-library program through `fmt --check`, `check`, `test`, `doc`, and
  hosted `glagol run` when the local toolchain is available
- `compiler/tests/standard_stdlib_composition_beta.rs` gates that composition
  example and guards against accidental local module copies
- project-local `.slovo/` build artifacts are ignored so `glagol run` output
  stays out of commits

### Explicit Deferrals

This release does not add syntax, generics, stable standard-library API
promises, stable ABI/layout guarantees, richer host error codes, networking, or
async runtime behavior.

## 1.0.0-beta.2

Release label: `1.0.0-beta.2`

Release date: 2026-05-22

Release state: runtime/resource foundation beta update

### Summary

Glagol `1.0.0-beta.2` contains the first runtime/resource foundation slice:

- Glagol recognizes `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`, and
  `std.fs.create_dir_result`
- LLVM lowering maps those calls to private hosted runtime symbols while
  preserving the existing concrete `result` layouts
- the test runner mirrors the hosted runtime policy for open/read/close file
  handles, status checks, file removal, and single-directory creation
- focused tests cover test-runner behavior, private lowering shape, hosted
  native execution, diagnostics, and the explicit `std.fs` source facade

This is still a beta resource foundation only. It does not claim stable
descriptor identity, writable streams, binary IO, directory handles, directory
enumeration, sockets, async resources, rich host errors, or a stable runtime
ABI.

## 1.0.0-beta.1

Release label: `1.0.0-beta.1`

Release date: 2026-05-22

Release state: first post-beta tooling hardening release

### Summary

Glagol `1.0.0-beta.1` keeps the `1.0.0-beta` language/compiler support
baseline and releases the first tooling-hardening slice:

- `glagol run <file.slo|project>` compiles through the existing hosted native
  build path, runs the produced executable, forwards stdout/stderr, and returns
  the program exit status
- `glagol clean <file.slo|project>` removes generated `.slovo/build` artifacts
- `glagol new --template binary|library|workspace` adds library and local
  workspace scaffolds beside the existing binary default
- `scripts/install.sh` installs `bin/glagol`, `share/slovo/std`, and
  `share/slovo/runtime/runtime.c`
- installed native builds discover the runtime C input relative to the
  executable, with `SLOVO_RUNTIME_C` and `GLAGOL_RUNTIME_C` overrides
- the release gate prints a concise final success summary

### Explicit Deferrals

This is a toolchain workflow slice only. It does not claim new source syntax,
a new stable ABI, a runtime resource model, networking surface, or package
registry.

## 1.0.0-beta

Release label: `1.0.0-beta`

Release date: 2026-05-21

Release state: first real general-purpose beta toolchain release

### Summary

Glagol `1.0.0-beta` integrates the completed unsigned `u32` / `u64` compiler
and stdlib breadth scope with the already promoted project/package workflow,
explicit std-source imports, concrete vector families, fixed arrays, structs,
enums, result/option, JSON diagnostics, formatter modes, generated docs, and
the paired local release gate.

The normative Glagol beta gate is `.llm/V1_0_0_BETA_RELEASE_GATE.md`. The beta
workflow proof lives in `compiler/tests/beta_1_0_0.rs`.

### Explicit Deferrals

No generics, no maps/sets, no remote registries, no networking/async runtime
surface, and no stable ABI/layout guarantees are included by beta.

## exp-125

Release label: `exp-125`

Release date: 2026-05-21

Release state: completed experimental precursor scope absorbed into `1.0.0-beta`

### Summary

exp-125 completed the connected unsigned `u32` / `u64` compiler and stdlib
breadth scope that directly enabled `1.0.0-beta`.

## exp-123

## exp-124

Release label: `exp-124`

Release date: 2026-05-21

Release state: gated experimental fixed-array enum-and-struct-elements compiler slice

### Summary

Glagol exp-124 gates one connected compiler broadening: fixed immutable arrays
now support direct known enum elements and current known non-recursive struct
elements alongside the earlier direct scalar and `string` lanes.

The release updates checker admission, formatter array rendering, LLVM
fixed-array typing for named element layouts, test-runner array values,
machine-diagnostic snapshots, promoted `array-enum` and
`array-struct-elements` fixtures and lowering snapshots, focused Glagol tests,
`llvm_smoke`/`lowering_inspector` inventories, and promotion-gate alignment.

### Explicit Deferrals

No zero-length arrays, no mutable arrays, no element mutation, no array
equality, no array printing, no nested arrays, no slices or generics, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-123

Release label: `exp-123`

Release date: 2026-05-21

Release state: gated experimental owned-vector benchmark-suite extension and whitepaper refresh

### Summary

Glagol exp-123 gates one connected benchmark/publication broadening: the local
benchmark scaffold inventory now includes `vec-i32-index-loop` and
`vec-string-eq-loop` beside `math-loop`, `branch-loop`, `parse-loop`,
`array-index-loop`, `string-eq-loop`, `array-struct-field-loop`, and
`enum-struct-payload-loop`.

The release keeps the shared runner model intact, adds the two new scaffold
directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations,
extends the focused benchmark scaffold test and promotion-gate inventory from
seven kernels to nine, reruns local benchmark evidence, and refreshes the
Glagol whitepaper/publication docs around the expanded suite and the current
experimental compiler surface through `exp-121`.

### Explicit Deferrals

No language-surface change, no compiler/runtime widening, no runtime ABI
claim, no benchmark thresholds, no cross-machine performance claims, no broad
optimizer guarantees, no PDF pipeline redesign, and no beta maturity are
included.

## exp-122

Release label: `exp-122`

Release date: 2026-05-21

Release state: gated experimental composite-data benchmark-suite extension and whitepaper refresh

### Summary

Glagol exp-122 gates one connected benchmark/publication broadening: the local
benchmark scaffold inventory now includes `array-struct-field-loop` and
`enum-struct-payload-loop` beside `math-loop`, `branch-loop`, `parse-loop`,
`array-index-loop`, and `string-eq-loop`.

The release keeps the shared runner model intact, adds the two new scaffold
directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations,
extends the focused benchmark scaffold test and promotion-gate inventory from
five kernels to seven, reruns local benchmark evidence, and refreshes the
Glagol whitepaper/publication docs around the expanded suite and the current
experimental compiler surface through `exp-121`.

During the final gate pass, Glagol also tightened one existing backend path:
`none f64` option aggregates now emit a typed `double 0.0` zero payload
instead of invalid `double 0`, preserving the already promoted `option f64`
surface under the clang-backed LLVM smoke gate.

### Explicit Deferrals

No language-surface change, no runtime ABI claim, no benchmark thresholds, no
cross-machine performance claims, no broad optimizer guarantees, no PDF
pipeline redesign, and no beta maturity are included.

## exp-121

Release label: `exp-121`

Release date: 2026-05-21

Release state: gated experimental non-recursive-struct enum-payload compiler slice

### Summary

Glagol exp-121 gates one connected enum-payload broadening: unary enum payload
variants now support current known non-recursive struct types.

The release updates checker and formatter payload admission, LLVM enum
aggregate lowering and zero-payload handling, test-runner struct payload
support, machine-diagnostic snapshots, the promoted `enum-payload-structs`
fixture and lowering snapshots, focused `enum_payload_structs_alpha`
coverage, and promotion-gate alignment. The fixture intentionally uses an
array-bearing struct payload so exp-120 is exercised indirectly without
widening enums to direct array payloads.

### Explicit Deferrals

No direct array/vec/option/result payloads, no equality requirement for
struct-payload enums, no mutation, no recursive/cyclic payloads, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-120

Release label: `exp-120`

Release date: 2026-05-21

Release state: gated experimental fixed-array struct-field compiler slice

### Summary

Glagol exp-120 gates one connected compiler broadening: direct struct field
declarations now support the already promoted fixed immutable array families
`(array i32 N)`, `(array i64 N)`, `(array f64 N)`, `(array bool N)`, and
`(array string N)`.

The release updates struct-field checker admission, machine-diagnostic
snapshots, the promoted `array-struct-fields` fixture and lowering snapshots,
focused `array_struct_fields_alpha` coverage, `llvm_smoke`/`lowering_inspector`
inventory, and promotion-gate alignment. The earlier array fixtures remain
valid as the underlying fixed-array lanes, and the earlier struct-field
fixtures remain valid as narrower sibling lanes.

### Explicit Deferrals

No zero-length arrays, no mutable arrays, no element mutation, no field
mutation, no nested arrays, no arrays of unsupported element kinds, no array
equality, no array printing, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-119

Release label: `exp-119`

Release date: 2026-05-21

Release state: gated experimental benchmark-suite extension and whitepaper refresh

### Summary

Glagol exp-119 gates one connected benchmark/publication broadening: the local
benchmark scaffold inventory now includes `array-index-loop` and
`string-eq-loop` beside the existing `math-loop`, `branch-loop`, and
`parse-loop` kernels.

The release keeps the shared runner model intact, adds the two new scaffold
directories with Slovo/C/Rust/Python/Clojure/Common Lisp implementations,
extends the focused benchmark scaffold test and promotion-gate inventory, and
refreshes the Glagol whitepaper/publication docs around the expanded suite and
the current experimental compiler surface.

### Explicit Deferrals

No language-surface change, no runtime ABI claim, no benchmark thresholds, no
cross-machine performance claims, no broad optimizer guarantees, no PDF
pipeline redesign, and no beta maturity are included.

## exp-118

Release label: `exp-118`

Release date: 2026-05-21

Release state: gated experimental string fixed-array compiler slice

### Summary

Glagol exp-118 gates one connected compiler broadening: fixed immutable arrays
now support `string` elements as a sibling lane beside the already promoted
direct scalar `i32`, `i64`, `f64`, and `bool` families.

The release updates array checker admission, formatter array rendering, LLVM
array typing/load/store/index lowering, test-runner array values, diagnostics
coverage, the promoted `array-string` and `array-string-value-flow` fixtures
and lowering snapshots, focused array-string tests, the promotion-gate
inventory, and the Glagol docs for this feature.

The earlier `array.slo`, `array-value-flow.slo`, `array-direct-scalars.slo`,
and `array-direct-scalars-value-flow.slo` fixtures remain valid as the
predecessor lanes.

### Explicit Deferrals

No array mutation, no array equality, no array printing, no nested arrays, no
arrays in struct fields, no zero-length arrays, no slices, no generics, no new
compiler-known runtime names, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-117

Release label: `exp-117`

Release date: 2026-05-21

Release state: gated experimental direct-scalar fixed-array compiler slice

### Summary

Glagol exp-117 gates one connected compiler broadening: fixed immutable arrays
now support the direct scalar element families `i32`, `i64`, `f64`, and `bool`
instead of only `i32`.

The release updates array checker admission, formatter array rendering, LLVM
array typing/load/store/index lowering, test-runner array values, diagnostics
coverage, the promoted `array-direct-scalars` and
`array-direct-scalars-value-flow` fixtures and lowering snapshots, focused
array tests, the promotion-gate inventory, and the Glagol docs for this
feature.

The earlier `array.slo` and `array-value-flow.slo` fixtures remain valid as
the narrower `i32` predecessor lane.

### Explicit Deferrals

No string arrays, no array mutation, no array equality, no array printing, no
nested arrays, no arrays in struct fields, no zero-length arrays, no slices,
no generics, no new compiler-known runtime names, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-116

Release label: `exp-116`

Release date: 2026-05-21

Release state: gated experimental direct enum-payload compiler slice

### Summary

Glagol exp-116 gates one connected compiler broadening: user-defined enum
payload variants now support unary direct `i32`, `i64`, `f64`, `bool`, and
`string` payloads instead of unary `i32` only.

The release keeps payloadless variants supported, keeps exactly one payload
per payload variant, and adds one conservative same-payload-kind-per-enum
rule whenever payload variants appear. That constraint keeps each enum on one
concrete LLVM payload layout without inventing generic sum-layout machinery.

The release updates the enum checker path, formatter enum rendering, LLVM enum
layout/equality/match lowering, test-runner enum payload support,
project/workspace enum import coverage, diagnostics coverage, the promoted
`enum-payload-direct-scalars` fixture and lowering snapshots, focused
enum-payload tests, the promotion-gate inventory, and the Glagol docs for
this feature.

### Explicit Deferrals

No vec/array/option/result/struct/enum payloads, no mixed payload kinds
inside one enum, no generics, no payload mutation, no new parser forms, no
new typed-AST constructs, no new compiler-known runtime names, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-115

Release label: `exp-115`

Release date: 2026-05-21

Release state: gated experimental composite-struct-field compiler slice

### Summary

Glagol exp-115 gates one connected compiler broadening: direct struct fields
now support the current concrete vec families, current concrete option/result
families, and current non-recursive struct types alongside the already
promoted direct scalar, string, and enum field families.

The release updates the struct-field checker path, recursive-layout rejection,
formatter struct-field rendering, diagnostics coverage, the promoted
`composite-struct-fields` fixture and lowering snapshots, focused
composite-struct tests, the promotion-gate inventory, and the Glagol docs for
this feature.

Lowering and typed AST forms do not widen: direct struct declarations,
constructors, field access, and current composite value families already
existed, so the release keeps the delta in checker/formatter/test/docs rather
than introducing new syntax or runtime names.

### Explicit Deferrals

No arrays as struct fields, no field mutation, no vector element mutation, no
option/result payload mutation, no recursive or cyclic struct layouts, no new
parser forms, no new typed-AST constructs, no new compiler-known runtime
names, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-113

Release label: `exp-113`

Release date: 2026-05-21

Release state: gated experimental mutable scalar-local compiler slice

### Summary

Glagol exp-113 gates one narrow compiler broadening: mutable `bool`, `i64`,
and `f64` locals now work through `var` and `set`.

The release updates the local-type checker path, formatter local-type
messaging, LLVM local emission, diagnostics coverage, the promoted
local-variable fixture and lowering snapshots, focused mutable-scalar tests,
the promotion-gate inventory, and the Glagol docs for this feature.

Lowering and typed AST forms do not widen: `lower_type`, `var`, and `set`
already existed, so the release keeps the delta in checker/backend/test/docs
rather than introducing new syntax or runtime names.

### Explicit Deferrals

No mutable `string`, vector, option/result, struct, or enum locals, no new
parser forms, no new typed-AST constructs, no new compiler-known runtime
names, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-114

Release label: `exp-114`

Release date: 2026-05-21

Release state: gated experimental mutable composite-local compiler slice

### Summary

Glagol exp-114 gates one narrow compiler broadening: same-type mutable local
reassignment now works through `var` and `set` for `string`, the current
concrete vec families, the current concrete option/result families, known
struct values, and current enum values.

The release updates the local-type checker path, mutable assignment gate,
formatter local rendering, LLVM local emission, diagnostics coverage, the
promoted `composite-locals` fixture and lowering snapshots, focused
mutable-composite tests, the promotion-gate inventory, and the Glagol docs
for this feature.

Lowering and typed AST forms do not widen: `lower_type`, `var`, `set`, and
`match` already existed, so the release keeps the delta in
checker/backend/test/docs rather than introducing new syntax or runtime
names.

### Explicit Deferrals

No mutable arrays, no field/element/payload mutation, no mutable generics or
new value families, no new parser forms, no new typed-AST constructs, no new
compiler-known runtime names, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-112

Release label: `exp-112`

Release date: 2026-05-21

Release state: gated experimental immutable bool-local compiler slice

### Summary

Glagol exp-112 gates one narrow compiler broadening: immutable `bool` locals
now work in `let` bindings.

The release updates the local-type checker path, LLVM local emission,
diagnostics coverage, one focused bool-local integration test, the
promotion-gate diagnostic inventory, and the Glagol docs for this feature.

Lowering and typed AST forms do not widen: `lower_type` already accepted
`bool`, and the release keeps the feature limited to immutable `let`
bindings only.

### Explicit Deferrals

No mutable `bool` locals, no new parser forms, no new compiler-known
runtime names, no broader local-mutation semantics, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-111

Release label: `exp-111`

Release date: 2026-05-21

Release state: gated experimental io stdin-helper stdlib gate

### Summary

Glagol exp-111 gates one connected broadening of the existing `std.io`
helper lane.

The release keeps the already promoted compiler/runtime semantics unchanged
and instead broadens the existing local and explicit-source `std.io`
fixtures, the focused source-helper/source-search tests, and the
promotion-gate inventory with:

- `read_stdin_result`
- `read_stdin_option`
- `read_stdin_or`
- `read_stdin_i32_result`
- `read_stdin_i32_option`
- `read_stdin_i32_or_zero`
- `read_stdin_i32_or`
- `read_stdin_i64_result`
- `read_stdin_i64_option`
- `read_stdin_i64_or_zero`
- `read_stdin_i64_or`
- `read_stdin_f64_result`
- `read_stdin_f64_option`
- `read_stdin_f64_or_zero`
- `read_stdin_f64_or`
- `read_stdin_bool_result`
- `read_stdin_bool_option`
- `read_stdin_bool_or_false`
- `read_stdin_bool_or`

The helper lane stays source-authored over the already promoted
`std.io.read_stdin_result`, the released `std.string.parse_*_result`
helpers, and the exp-109 `ok_or_none_*` bridge helpers. The Glagol local
fixture adds explicit local `result.slo` and `string.slo` bridge modules so
the widened io facade remains ordinary source composition rather than new
compiler-known runtime names.

### Explicit Deferrals

No parser/checker/backend/runtime widening, no new compiler-known
`std.*` runtime names, no trap-based `std.io.read_stdin`, no line/read-line
or prompt APIs, no terminal mode, no binary/streaming/async stdin, no
automatic std imports, no stable ABI/layout guarantees, and no beta maturity
are included.

## exp-110

Release label: `exp-110`

Release date: 2026-05-21

Release state: gated experimental string/env/fs/process/cli option-helper stdlib gate

### Summary

Glagol exp-110 gates one connected broadening of the existing `std.string`,
`std.env`, `std.fs`, `std.process`, and `std.cli` helper lanes.

The release keeps the already promoted compiler/runtime semantics unchanged
and instead broadens the existing local and explicit-source fixtures, the
focused source-helper/source-search tests, and the promotion-gate inventory
with:

- `parse_i32_option`
- `parse_i64_option`
- `parse_f64_option`
- `parse_bool_option`
- `get_option`
- `get_i32_option`
- `get_i64_option`
- `get_f64_option`
- `get_bool_option`
- `read_text_option`
- `read_i32_option`
- `read_i64_option`
- `read_f64_option`
- `read_bool_option`
- `arg_option`
- `arg_i32_option`
- `arg_i64_option`
- `arg_f64_option`
- `arg_bool_option`
- `arg_text_option`
- `arg_i32_option`
- `arg_i64_option`
- `arg_f64_option`
- `arg_bool_option`

The helper lanes stay source-authored over the already promoted concrete
result families plus the exp-109 `ok_or_none_*` bridge helpers. The Glagol
local fixtures add explicit local `result.slo` bridge modules so the option
helpers remain ordinary source composition rather than new compiler-known
runtime names.

### Explicit Deferrals

No parser/checker/backend/runtime widening, no new compiler-known
`std.*` runtime names, no stdin helpers, no vec work, no automatic std
imports, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-109

Release label: `exp-109`

Release date: 2026-05-21

Release state: gated experimental option/result bridge stdlib gate

### Summary

Glagol exp-109 gates one connected broadening of the existing `std.option`
and `std.result` helper lanes.

The release keeps the already promoted concrete option/result semantics
unchanged and instead broadens the local `std-layout-local-option/` and
`std-layout-local-result/` fixtures, the explicit `std-import-option/` and
`std-import-result/` fixtures, the workspace `std-import-option/` fixture,
the focused source-helper/source-search tests, and the promotion-gate
inventory with:

- `some_or_err_i32`
- `some_or_err_i64`
- `some_or_err_f64`
- `some_or_err_bool`
- `some_or_err_string`
- `ok_or_none_i32`
- `ok_or_none_i64`
- `ok_or_none_string`
- `ok_or_none_f64`
- `ok_or_none_bool`

The helper lanes stay concrete and source-authored over the already promoted
option/result forms. `std.option` uses raw `ok` and `err` constructors
directly, and `std.result` uses raw `some` and `none` constructors directly,
without introducing local bridge shim modules, new compiler-known
`std.option.*` or `std.result.*` runtime names, or compiler/runtime
widening.

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no broader
`map`/`and_then`/`transpose`/`flatten` package, no new payload families, no
automatic or compiler-loaded std imports, no stable ABI/layout guarantees,
and no beta maturity are included.

## exp-108

Release label: `exp-108`

Release date: 2026-05-21

Release state: gated experimental vec-string/vec-f64/vec-bool prefix/suffix stdlib gate

### Summary

Glagol exp-108 gates one connected broadening of the existing vec-string,
vec-f64, and vec-bool helper lanes.

The release keeps the already promoted concrete `(vec string)`, `(vec f64)`,
and `(vec bool)` compiler/runtime semantics unchanged and instead broadens
the local `std-layout-local-vec_string/`, `std-layout-local-vec_f64/`, and
`std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_string/`,
`std-import-vec_f64/`, and `std-import-vec_bool/` fixtures, the focused
source-helper/source-search tests, and the promotion-gate inventory with:

- `starts_with`
- `without_prefix`
- `ends_with`
- `without_suffix`

The helper lanes stay recursive and immutable with no `var` or `set`, stay
concrete to the three existing vec families, and reuse only the already
promoted runtime names:

- `std.vec.string.empty`
- `std.vec.string.append`
- `std.vec.string.len`
- `std.vec.string.index`
- `std.vec.f64.empty`
- `std.vec.f64.append`
- `std.vec.f64.len`
- `std.vec.f64.index`
- `std.vec.bool.empty`
- `std.vec.bool.append`
- `std.vec.bool.len`
- `std.vec.bool.index`

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no sorting,
mapping, filtering, no nested/container vecs, no mutating or capacity APIs,
no stable ABI/layout guarantees, and no beta maturity are included.

## exp-107

Release label: `exp-107`

Release date: 2026-05-21

Release state: gated experimental vec-string/vec-f64/vec-bool edit-helper stdlib gate

### Summary

Glagol exp-107 gates one connected broadening of the existing vec-string,
vec-f64, and vec-bool helper lanes.

The release keeps the already promoted concrete `(vec string)`, `(vec f64)`,
and `(vec bool)` compiler/runtime semantics unchanged and instead broadens
the local `std-layout-local-vec_string/`, `std-layout-local-vec_f64/`, and
`std-layout-local-vec_bool/` fixtures, the explicit `std-import-vec_string/`,
`std-import-vec_f64/`, and `std-import-vec_bool/` fixtures, the focused
source-helper/source-search tests, and the promotion-gate inventory with:

- `insert_at`
- `insert_range`
- `replace_at`
- `replace_range`
- `remove_at`
- `remove_range`

The helper lanes stay recursive and immutable with no `var` or `set`, stay
concrete to the three existing vec families, and reuse only the already
promoted runtime names:

- `std.vec.string.empty`
- `std.vec.string.append`
- `std.vec.string.len`
- `std.vec.string.index`
- `std.vec.f64.empty`
- `std.vec.f64.append`
- `std.vec.f64.len`
- `std.vec.f64.index`
- `std.vec.bool.empty`
- `std.vec.bool.append`
- `std.vec.bool.len`
- `std.vec.bool.index`

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no prefix/suffix
helpers, no sorting/mapping/filtering, no nested/container vecs, no
mutating or capacity APIs, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-106

Release label: `exp-106`

Release date: 2026-05-21

Release state: gated experimental vec-f64/vec-bool option-query stdlib gate

### Summary

Glagol exp-106 gates one connected broadening of the existing vec-f64 and
vec-bool helper lanes.

The release keeps the already promoted concrete `(vec f64)` and `(vec bool)`
compiler/runtime semantics unchanged and instead broadens the local
`std-layout-local-vec_f64/` and `std-layout-local-vec_bool/` fixtures, the
explicit `std-import-vec_f64/` and `std-import-vec_bool/` fixtures, the
focused source-helper/source-search tests, and the promotion-gate inventory
with:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

The helper lanes stay recursive and immutable with no `var` or `set`, stay
concrete to `(vec f64)` and `(vec bool)` plus the already promoted concrete
option families they return, and reuse only the already promoted runtime
names:

- `std.vec.f64.empty`
- `std.vec.f64.append`
- `std.vec.f64.len`
- `std.vec.f64.index`
- `std.vec.bool.empty`
- `std.vec.bool.append`
- `std.vec.bool.len`
- `std.vec.bool.index`

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no edit helpers,
no nested/container vecs, no mutating or capacity APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-105

Release label: `exp-105`

Release date: 2026-05-21

Release state: gated experimental vec-f64/vec-bool transform-helper stdlib gate

### Summary

Glagol exp-105 gates one connected broadening of the existing vec-f64 and
vec-bool helper lanes.

The release keeps the already promoted concrete `(vec f64)` and `(vec bool)`
compiler/runtime semantics unchanged and instead broadens the local
`std-layout-local-vec_f64/` and `std-layout-local-vec_bool/` fixtures, the
explicit `std-import-vec_f64/` and `std-import-vec_bool/` fixtures, the
focused source-helper/source-search tests, and the promotion-gate inventory
with:

- `concat`
- `take`
- `drop`
- `reverse`
- `subvec`

The helper lanes stay recursive and immutable with no `var` or `set`, stay
concrete to `(vec f64)` and `(vec bool)` only, and reuse only the already
promoted runtime names:

- `std.vec.f64.empty`
- `std.vec.f64.append`
- `std.vec.f64.len`
- `std.vec.f64.index`
- `std.vec.bool.empty`
- `std.vec.bool.append`
- `std.vec.bool.len`
- `std.vec.bool.index`

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no option/result
helpers, no edit helpers, no nested/container vecs, no mutating or capacity
APIs, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-104

Release label: `exp-104`

Release date: 2026-05-21

Release state: gated experimental vec-bool baseline compiler/runtime plus stdlib gate

### Summary

Glagol exp-104 gates the first concrete `(vec bool)` slice.

The release extends the checker, formatter, LLVM backend, runtime, std
runtime inventory, and test runner so immutable `(vec bool)` params,
returns, locals, direct `std.vec.bool.empty/append/len/index` calls, and
same-family vec-bool equality work end to end. It also adds the small scalar
bool-equality enablement required by the source-authored helper lane. The
release adds the local `std-layout-local-vec_bool/` fixture, the explicit
`std-import-vec_bool/` fixture, focused vec-bool collections/source helper/
source search coverage, diagnostics snapshot refreshes, and promotion-gate
inventory for the connected `std.vec_bool` helper inventory:

- `empty`
- `append`
- `len`
- `at`
- `singleton`
- `append2`
- `append3`
- `pair`
- `triple`
- `is_empty`
- `index_or`
- `first_or`
- `last_or`
- `contains`
- `count_of`

The source helpers stay recursive and immutable with no `var` or `set`, stay
concrete to `(vec bool)` only, and reuse only the already promoted
`std.vec.bool.empty`, `std.vec.bool.append`, `std.vec.bool.len`, and
`std.vec.bool.index` runtime names.

### Explicit Deferrals

No new compiler-known `std.*` runtime names beyond the vec-bool family, no
generics, no option-query helpers, no transform/edit helpers, no nested vecs
or vecs inside other containers, no mutating or capacity APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-103

Release label: `exp-103`

Release date: 2026-05-21

Release state: gated experimental vec-f64 baseline compiler/runtime plus stdlib gate

### Summary

Glagol exp-103 gates the first concrete `(vec f64)` slice.

The release extends the checker, formatter, LLVM backend, runtime, std
runtime inventory, and test runner so immutable `(vec f64)` params, returns,
locals, direct `std.vec.f64.empty/append/len/index` calls, and same-family
vec-f64 equality work end to end. It also adds the local
`std-layout-local-vec_f64/` fixture, the explicit `std-import-vec_f64/`
fixture, focused vec-f64 diagnostics and promotion-gate coverage, and the
connected `std.vec_f64` helper inventory:

- `empty`
- `append`
- `len`
- `at`
- `singleton`
- `append2`
- `append3`
- `pair`
- `triple`
- `is_empty`
- `index_or`
- `first_or`
- `last_or`
- `contains`
- `sum`

The source helpers stay recursive and immutable with no `var` or `set`, stay
concrete to `(vec f64)` only, and reuse only the already promoted
`std.vec.f64.empty`, `std.vec.f64.append`, `std.vec.f64.len`, and
`std.vec.f64.index` runtime names.

### Explicit Deferrals

No new compiler-known `std.*` runtime names beyond the vec-f64 family, no
generics, no option-query helpers, no transform/edit helpers, no nested vecs
or vecs inside other containers, no mutating or capacity APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-102

Release label: `exp-102`

Release date: 2026-05-21

Release state: gated experimental option-bool-f64 baseline compiler/runtime plus stdlib gate

### Summary

Glagol exp-102 gates the concrete `(option f64)` and `(option bool)` slice.

The release extends the checker, formatter, LLVM backend, and test runner so
immutable `(option f64)` and `(option bool)` params, returns, locals, direct
`some`/`none` construction, `is_some`, `is_none`, `unwrap_some`, and
source-level `match` payload binding work end to end. It also broadens the
local `std-layout-local-option/` fixture, the explicit `std-import-option/`
fixture, the workspace `std-import-option/` fixture, focused option-result
coverage, diagnostics snapshots, and promotion-gate inventory, and it stages
the connected `std.option` f64/bool helper inventory:

- `some_f64`
- `none_f64`
- `is_some_f64`
- `is_none_f64`
- `unwrap_some_f64`
- `unwrap_or_f64`
- `some_bool`
- `none_bool`
- `is_some_bool`
- `is_none_bool`
- `unwrap_some_bool`
- `unwrap_or_bool`

The source helpers stay explicit and concrete, and the compiler/runtime slice
stays concrete to `(option i32)`, `(option i64)`, `(option f64)`,
`(option bool)`, and `(option string)`.

### Explicit Deferrals

No compiler-known `std.option.*` runtime names, no generic option helpers,
no option payload families beyond `i32`, `i64`, `f64`, `bool`, and `string`,
no nested or container option support, no stable ABI/layout guarantees, and
no beta maturity are included.

## exp-101

Release label: `exp-101`

Release date: 2026-05-21

Release state: gated experimental vec-string option/transform stdlib gate

### Summary

Glagol exp-101 gates the broadened concrete `(vec string)` helper lane.

The release updates the local `std-layout-local-vec_string/` fixture, the
explicit `std-import-vec_string/` fixture, focused vec-string source-helper
and source-search coverage, and promotion-gate inventory with one connected
helper package:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`
- `concat`
- `take`
- `drop`
- `reverse`
- `subvec`

The source helpers stay recursive and immutable with no `var` or `set`, stay
concrete to `(vec string)` plus raw current `(option string)` /
`(option i32)` forms only, and reuse only the already promoted
`std.vec.string.empty`, `std.vec.string.append`, `std.vec.string.len`, and
`std.vec.string.index` runtime names.

### Explicit Deferrals

No new compiler-known `std.*` runtime names, no generics, no edit helpers,
no prefix/suffix helpers, no nested vecs or vecs inside other containers, no
mutating or capacity APIs, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-100

Release label: `exp-100`

Release date: 2026-05-21

Release state: gated experimental option-string baseline compiler/runtime plus stdlib gate

### Summary

Glagol exp-100 gates the first concrete `(option string)` slice.

The release extends the checker, formatter, LLVM backend, and test runner so
immutable `(option string)` params, returns, locals, direct `some`/`none`
construction, `is_some`, `is_none`, `unwrap_some`, and source-level `match`
payload binding work end to end. It also broadens the local
`std-layout-local-option/` fixture, the explicit `std-import-option/`
fixture, the workspace `std-import-option/` fixture, focused option/result
coverage, and promotion-gate inventory, and it stages the connected
`std.option` string helper inventory:

- `some_string`
- `none_string`
- `is_some_string`
- `is_none_string`
- `unwrap_some_string`
- `unwrap_or_string`

The source helpers stay explicit and concrete, and the compiler/runtime slice
stays concrete to `(option i32)`, `(option i64)`, and `(option string)`.

### Explicit Deferrals

No compiler-known `std.option.*` runtime names, no generic option helpers,
no option payload families beyond `i32`, `i64`, and `string`, no nested or
container option support, no stable ABI/layout guarantees, and no beta
maturity are included.

## exp-99

Release label: `exp-99`

Release date: 2026-05-21

Release state: gated experimental vec-string baseline compiler/runtime plus stdlib gate

### Summary

Glagol exp-99 gates the first concrete `(vec string)` slice.

The release extends the checker, formatter, LLVM backend, runtime, std
runtime inventory, and test runner so immutable `(vec string)` params,
returns, locals, direct `std.vec.string.empty`, `std.vec.string.append`,
`std.vec.string.len`, `std.vec.string.index`, and concrete vec-string
equality work end to end. It also adds `examples/vec-string.slo`, adds the
local `std-layout-local-vec_string/` fixture, adds the explicit
`std-import-vec_string/` fixture, adds focused diagnostics and promotion-gate
coverage, and stages the frozen `std.vec_string` helper inventory:

- `empty`
- `append`
- `len`
- `at`
- `singleton`
- `append2`
- `append3`
- `pair`
- `triple`
- `is_empty`
- `index_or`
- `first_or`
- `last_or`
- `contains`
- `count_of`

The source helpers stay recursive and immutable with no `var` or `set`, use
only the promoted `std.vec.string` runtime names, and keep real-program
coverage focused on `contains` and `count_of`.

In Glagol-only repo states, the explicit-source `std-import-vec_string/`
fixture now remains authored and format-checked even if sibling
`lib/std/vec_string.slo` has not landed yet; the full check/test lane for
that fixture still depends on the paired Slovo source file.

### Explicit Deferrals

No generics, no other vec element families, no option-query helpers, no
transform/range/edit helpers, no nested vecs or vecs inside other
containers, no mutating or capacity APIs, no stable ABI/layout guarantees,
and no beta maturity are included.

## exp-98

Release label: `exp-98`

Release date: 2026-05-21

Release state: gated experimental vec-i64-edit-helper stdlib gate

### Summary

Glagol exp-98 gates the concrete edit-helper extension for the staged
`std.vec_i64` source-authored facade.

The release updates the local `std-layout-local-vec_i64/` fixture, updates
the explicit `std-import-vec_i64/` fixture against repo-root
`lib/std/vec_i64.slo`, adds focused integration coverage, and extends
promotion-gate inventory and sibling Slovo alignment checks for these
helpers:

- `insert_at`
- `insert_range`
- `replace_at`
- `replace_range`
- `remove_at`
- `remove_range`

The helpers reuse only the existing `std.vec.i64` runtime family plus the
already promoted `(option i32)` and `(option i64)` surface.
`insert_at(values,position,value)` inserts before `position`, appends when
`position == len(values)`, and otherwise leaves out-of-range inputs unchanged.
`insert_range(values,position,inserted)` follows the same position rules while
preserving left-to-right order of both vectors. `replace_at` and
`remove_at` leave negative and out-of-range positions unchanged. The range
helpers leave `values` unchanged for negative starts, degenerate or reversed
ranges, and `start >= len(values)`; overlong `end_exclusive` values edit
through the tail; and valid edits preserve element order while leaving source
vectors unchanged. The local Glagol-owned fixture stays source-authored,
recursive, and immutable without `var` or `set`, and the release adds no new
parser, checker, runtime, formatter, or LLVM semantics.

### Explicit Deferrals

No generic vectors, no new compiler-known `std.*` runtime names, no automatic
standard-library imports, no compiler-loaded std source, no mutable vector
APIs, no capacity/reserve management, no iterators, sorting, mapping,
filtering, stable ABI/layout guarantees, or beta maturity are included.

## exp-97

Release label: `exp-97`

Release date: 2026-05-21

Release state: gated experimental vec-i64-transform-helper stdlib gate

### Summary

Glagol exp-97 gates the concrete transform-helper extension for the staged
`std.vec_i64` source-authored facade.

The release updates the local `std-layout-local-vec_i64/` fixture, updates
the explicit `std-import-vec_i64/` fixture against repo-root
`lib/std/vec_i64.slo`, adds focused integration coverage, and extends
promotion-gate inventory and sibling Slovo alignment checks for these
helpers:

- `concat`
- `take`
- `drop`
- `reverse`
- `subvec`

The helpers reuse only the existing `std.vec.i64` runtime family plus the
already promoted `(option i32)` and `(option i64)` surface. `concat(left,right)`
preserves left-to-right element order, `take(values,count)` treats negative
counts as zero and saturates to the full vector, `drop(values,count)` treats
negative counts as zero and saturates to the empty vector, `reverse(values)`
returns a new vector in reverse order, and `subvec(values,start,end_exclusive)`
returns the bounded middle slice while using the same concrete vec_i64 lane.
The local Glagol-owned fixture stays source-authored, recursive, and
immutable without `var` or `set`, and the release adds no new parser,
checker, runtime, formatter, or LLVM semantics.

### Explicit Deferrals

No vec_i64 insert/replace/remove helpers, no generics, no new compiler-known
`std.*` runtime names, no mutating vector or capacity APIs, no iterators,
sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity
are included.

## exp-96

Release label: `exp-96`

Release date: 2026-05-20

Release state: gated experimental vec-i64-option-query-helper stdlib gate

### Summary

Glagol exp-96 gates the concrete option-query helper extension for the staged
`std.vec_i64` source-authored facade.

The release updates the local `std-layout-local-vec_i64/` fixture, updates
the explicit `std-import-vec_i64/` fixture against repo-root
`lib/std/vec_i64.slo`, adds focused integration coverage, and extends
promotion-gate inventory and sibling Slovo alignment checks for these
helpers:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

The helpers reuse only the existing `std.vec.i64` runtime family plus the
already promoted `(option i32)` and `(option i64)` surface.
`index_option(values,position)`, `first_option(values)`, and
`last_option(values)` return concrete `(option i64)` observations of vec
elements; `index_of_option(values,target)` and
`last_index_of_option(values,target)` return concrete `(option i32)` position
results. The local Glagol-owned fixture stays source-authored, recursive, and
immutable without `var` or `set`, and the release adds no new parser,
checker, runtime, formatter, or LLVM semantics.

### Explicit Deferrals

No vec_i64 transform/range/edit helpers, no generics, no new compiler-known
`std.*` runtime names, no mutating vector or capacity APIs, no iterators,
sorting, mapping, filtering, stable ABI/layout guarantees, or beta maturity
are included.

## exp-95

Release label: `exp-95`

Release date: 2026-05-20

Release state: gated experimental option-i64-baseline compiler/runtime and stdlib gate

### Summary

Glagol exp-95 gates the first concrete `(option i64)` baseline across the
compiler, local source fixtures, and explicit-source `std.option` import path.

The release broadens the checker, formatter, LLVM backend, and test runner so
immutable `(option i64)` params, returns, locals, `some`, `none`, `is_some`,
`is_none`, `unwrap_some`, and source-level `match` payload bindings work end
to end. It adds the local `std-layout-local-option/` i64 helper coverage,
widens the explicit `std-import-option/` project against repo-root
`lib/std/option.slo`, extends diagnostics snapshots and promotion-gate
inventory, and broadens the staged helper surface with:

- `some_i64`
- `none_i64`
- `is_some_i64`
- `is_none_i64`
- `unwrap_some_i64`
- `unwrap_or_i64`

### Explicit Deferrals

No compiler-known `std.option.*` runtime names, no generic option helpers, no
option payload families beyond `i32` and `i64`, no nested/container option
support, no option equality or printing, no stable ABI/layout guarantee, no
manifest schema changes, and no beta maturity are included.

## exp-94

Release label: `exp-94`

Release date: 2026-05-20

Release state: gated experimental vec-i64-baseline compiler/runtime and stdlib gate

### Summary

Glagol exp-94 gates the concrete `(vec i64)` runtime and compiler surface plus
the first local and explicit-source `std.vec_i64` facade baseline.

The release promotes `std.vec.i64.empty`, `std.vec.i64.append`,
`std.vec.i64.len`, and `std.vec.i64.index`; adds `(vec i64)` equality;
extends the checker, formatter, lowering, LLVM backend, runtime, test runner,
and runtime catalog for concrete `(vec i64)` values; adds the local
`std-layout-local-vec_i64/` fixture; adds the explicit `std-import-vec_i64/`
fixture against repo-root `lib/std/vec_i64.slo`; adds focused integration
coverage; and extends
promotion-gate inventory for this connected baseline:

- `empty`
- `append`
- `len`
- `at`
- `singleton`
- `append2`
- `append3`
- `pair`
- `triple`
- `is_empty`
- `index_or`
- `first_or`
- `last_or`
- `contains`
- `sum`

The source surface stays concrete to `(vec i64)` and immutable. It reuses only
the promoted `std.vec.i64` runtime names, leaves source vectors unchanged, and
does not widen option/result payload families or introduce generic vector
semantics.

### Explicit Deferrals

No generic vectors, no vector payload families beyond the concrete `(vec i32)`
and `(vec i64)` slices, no automatic standard-library imports, no edits under
`slovo/**`, no compiler-loaded std source beyond the existing explicit search
rules, no new compiler-known `std.*` runtime names beyond `std.vec.i64.*`, no
slice or view types, no mutable vector locals, no mutating vector APIs, no
option/result payload widening, no vector families for `f64`, `string`, or
`bool`, no capacity or reserve management, no sorting, mapping, filtering, or
iterator APIs, no stable ABI/layout guarantees, and no beta maturity are
included.

## exp-93

Release label: `exp-93`

Release date: 2026-05-20

Release state: gated experimental vec-i32-count-of-helper stdlib gate

### Summary

Glagol exp-93 gates the concrete count-of helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `count_of`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `len` and `at`, plus equality and `while`.
`count_of(values,target)` returns the number of elements of `values` equal to
`target`; returns `0` for empty and no-match cases; counts repeated matches
exactly; leaves the source vector unchanged; and adds no new parser,
checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no broader aggregation/filter families beyond the current concrete vec
surface, no slice or view types, no mutable `(vec i32)` local support, no
capacity or reserve management, no sorting, mapping, filtering, or iterator
APIs, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-92

Release label: `exp-92`

Release date: 2026-05-20

Release state: gated experimental vec-i32-without-prefix-helper stdlib gate

### Summary

Glagol exp-92 gates the concrete without-prefix helper extension for the
staged `std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `without_prefix`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `starts_with`, `drop`, and `len`.
`without_prefix(values,prefix)` removes a matching leading prefix from
`values`; returns `values` unchanged for empty, longer, or mismatched
prefixes; returns `(empty)` for an exact match; preserves the order of the
remaining suffix; leaves both source vectors unchanged; and adds no new
parser, checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no broader prefix/suffix helper families beyond the current `starts_with`,
`without_prefix`, `ends_with`, and `without_suffix` helpers, no slice or
view types, no mutable `(vec i32)` local support, no capacity or reserve
management, no sorting, mapping, filtering, or iterator APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-91

Release label: `exp-91`

Release date: 2026-05-20

Release state: gated experimental vec-i32-without-suffix-helper stdlib gate

### Summary

Glagol exp-91 gates the concrete without-suffix helper extension for the
staged `std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `without_suffix`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `ends_with`, `take`, and `len`.
`without_suffix(values,suffix)` removes a matching trailing suffix from
`values`; returns `values` unchanged for empty, longer, or mismatched
suffixes; returns `(empty)` for an exact match; preserves the order of the
remaining prefix; leaves both source vectors unchanged; and adds no new
parser, checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no broader prefix/suffix helper families beyond the current `starts_with`,
`ends_with`, and `without_suffix` helpers, no slice or view types, no
mutable `(vec i32)` local support, no capacity or reserve management, no
sorting, mapping, filtering, or iterator APIs, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-90

Release label: `exp-90`

Release date: 2026-05-20

Release state: gated experimental vec-i32-ends-with-helper stdlib gate

### Summary

Glagol exp-90 gates the concrete ends-with helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `ends_with`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `drop` and vec equality.
`ends_with(values,suffix)` returns `true` exactly when `values` ends with all
elements of `suffix` in order; returns `true` for an empty suffix; returns
`false` when `len(suffix) > len(values)`; returns `true` for equal vectors
and shorter matching suffixes; returns `false` for mismatched suffixes;
leaves both source vectors unchanged; and adds no new parser, checker,
runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no broader prefix/suffix query families beyond the current `starts_with` and
`ends_with` helpers, no slice or view types, no mutable `(vec i32)` local
support, no capacity or reserve management, no sorting, mapping, filtering,
or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are
included.

## exp-89

Release label: `exp-89`

Release date: 2026-05-20

Release state: gated experimental vec-i32-starts-with-helper stdlib gate

### Summary

Glagol exp-89 gates the concrete starts-with helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `starts_with`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take` and vec equality.
`starts_with(values,prefix)` returns `true` exactly when `values` begins
with all elements of `prefix` in order; returns `true` for an empty prefix;
returns `false` when `len(prefix) > len(values)`; returns `true` for equal
vectors and shorter matching prefixes; returns `false` for mismatched
prefixes; leaves both source vectors unchanged; and adds no new parser,
checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no broader prefix/suffix query families beyond this single helper, no slice
or view types, no mutable `(vec i32)` local support, no capacity or reserve
management, no sorting, mapping, filtering, or iterator APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-88

Release label: `exp-88`

Release date: 2026-05-20

Release state: gated experimental vec-i32-replace-range-helper stdlib gate

### Summary

Glagol exp-88 gates the concrete replace-range helper extension for the
staged `std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `replace_range`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`.
`replace_range(values,start,end_exclusive,replacement)` returns `values`
unchanged when `start < 0`, when `end_exclusive <= start`, or when
`start >= len(values)`; replaces the half-open range
`[start, end_exclusive)` when both bounds are in range; replaces the tail
from `start` when `end_exclusive >= len(values)`; preserves the order of both
vectors; leaves both source vector values unchanged; and adds no new parser,
checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no bulk-edit APIs beyond this single contiguous replacement helper, no slice
or view types, no mutable `(vec i32)` local support, no capacity or reserve
management, no sorting, mapping, filtering, or iterator APIs, no stable
ABI/layout guarantees, and no beta maturity are included.

## exp-87

Release label: `exp-87`

Release date: 2026-05-20

Release state: gated experimental vec-i32-insert-range-helper stdlib gate

### Summary

Glagol exp-87 gates the concrete insert-range helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `insert_range`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`.
`insert_range(values,position,inserted)` returns `values` unchanged when
`position < 0` or `position > len(values)`; inserts `inserted` before the
current element when `0 <= position < len(values)`; appends `inserted` when
`position == len(values)`; preserves the order of both vectors; leaves both
source vector values unchanged; and adds no new parser, checker, runtime,
formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no bulk-edit APIs beyond this single contiguous range insertion helper, no
multi-position insertion helpers, no mutable `(vec i32)` local support, no
capacity or reserve management, no sorting, mapping, filtering, or iterator
APIs, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-86

Release label: `exp-86`

Release date: 2026-05-20

Release state: gated experimental vec-i32-remove-range-helper stdlib gate

### Summary

Glagol exp-86 gates the concrete remove-range helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `remove_range`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`.
`remove_range(values,start,end_exclusive)` returns `values` unchanged when
`start < 0`, when `end_exclusive <= start`, or when `start >= len(values)`;
returns the prefix before `start` when `end_exclusive >= len(values)`;
otherwise returns a new vector with the half-open range
`[start, end_exclusive)` removed, preserves the order of the remaining
elements, and leaves the source vector value unchanged. Glagol adds no new
parser, checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no bulk-edit APIs beyond this single contiguous removal helper, no mutable
`(vec i32)` local support, no capacity or reserve management, no sorting,
mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-85

Release label: `exp-85`

Release date: 2026-05-20

Release state: gated experimental vec-i32-subvec-helper stdlib gate

### Summary

Glagol exp-85 gates the concrete subvector-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `subvec`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `drop` and `take`. `subvec(values,start,end_exclusive)`
returns the empty vector when `start < 0`, when `end_exclusive <= start`, or
when `start >= len(values)`; returns the remaining tail from `start` when
`end_exclusive > len(values)`; otherwise returns a copied contiguous
subvector `[start, end_exclusive)` with preserved left-to-right order; and
leaves the source vector value unchanged. Glagol adds no new parser, checker,
runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no slice or view types, no mutable `(vec i32)` local support, no capacity or
reserve management, no sorting, mapping, filtering, or iterator APIs, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-84

Release label: `exp-84`

Release date: 2026-05-20

Release state: gated experimental vec-i32-insert-helper stdlib gate

### Summary

Glagol exp-84 gates the concrete insert-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `insert_at`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`.
`insert_at(values,position,value)` returns `values` unchanged when
`position < 0` or `position > len(values)`; inserts `value` before the current
element when `0 <= position < len(values)`; appends `value` when
`position == len(values)`; preserves the surrounding order; increases the
result length by one for valid insertions; and leaves the source vector value
unchanged. Glagol adds no new parser, checker, runtime, formatter, or LLVM
semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no bulk-edit APIs, no multi-index insertion, no mutable `(vec i32)` local
support, no capacity or reserve management, no sorting, mapping, filtering,
or iterator APIs, no stable ABI/layout guarantees, and no beta maturity are
included.

## exp-83

Release label: `exp-83`

Release date: 2026-05-20

Release state: gated experimental vec-i32-remove-helper stdlib gate

### Summary

Glagol exp-83 gates the concrete remove-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `remove_at`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`. `remove_at(values,position)`
returns `values` unchanged when `position < 0` or `position >= len(values)`;
otherwise it returns a new vector with the element at `position` removed,
preserves the order of the remaining elements, shortens the result length by
one, and leaves the source vector value unchanged. Glagol adds no new parser,
checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no new private recursive helper loops,
no insert helpers, no bulk-edit APIs, no multi-index removal, no mutable
`(vec i32)` local support, no capacity or reserve management, no sorting,
mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-82

Release label: `exp-82`

Release date: 2026-05-20

Release state: gated experimental vec-i32-replace-helper stdlib gate

### Summary

Glagol exp-82 gates the concrete replace-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `replace_at`

The helper is an ordinary source-authored composition over the existing
promoted `std.vec.i32` runtime family and the already staged `std.vec_i32`
wrappers for `empty`, `append`, `len`, and `at`, plus the already staged
source helpers `take`, `drop`, and `concat`.
`replace_at(values,position,replacement)` returns `values` unchanged when
`position < 0` or `position >= len(values)`; otherwise it returns a new vector
with the same length and order except for the replaced slot. Glagol adds no
new parser, checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no private mutation loops, no insert or
remove helpers, no bulk-edit APIs, no mutable `(vec i32)` local support, no
capacity or reserve management, no sorting, mapping, filtering, or iterator
APIs, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-81

Release label: `exp-81`

Release date: 2026-05-20

Release state: released experimental vec-i32-range-helper stdlib gate

### Summary

Glagol exp-81 gates the concrete range-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for this helper:

- `range`

The helper is ordinary source-authored recursion over the existing promoted
`std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for
`empty`, `append`, `len`, and `at`. `range(start,end_exclusive)` generates the
ascending half-open sequence `[start, start + 1, ..., end_exclusive - 1]`,
returns the empty vector when `end_exclusive <= start`, and accepts negative
bounds. The recursive generation helper remains private to the fixture source.
Glagol adds no new parser, checker, runtime, formatter, or LLVM semantics for
this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no edit helpers, no descending, stepped,
or inclusive range variants, no mutable `(vec i32)` local support, no capacity
or reserve management, no sorting, mapping, filtering, or iterator APIs, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-80

Release label: `exp-80`

Release date: 2026-05-20

Release state: released experimental vec-i32-generated-constructor-helper stdlib gate

### Summary

Glagol exp-80 gates the concrete generated-constructor-helper extension for
the staged `std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for these helpers:

- `repeat`
- `range_from_zero`

The helpers are ordinary source-authored recursion over the existing promoted
`std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for
`empty`, `append`, `len`, and `at`. `repeat(value,count)` returns the empty
vector for `count <= 0`, and `range_from_zero(count)` generates the ascending
half-open sequence `[0, 1, ..., count - 1]`, returning the empty vector for
`count <= 0`. The recursive generation helpers remain private to the fixture
source. Glagol adds no new parser, checker, runtime, formatter, or LLVM
semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no edit helpers, no public `range`
helper, no descending, stepped, or inclusive range variants, no mutable
`(vec i32)` local support, no capacity or reserve management, no sorting,
mapping, filtering, or iterator APIs, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-79

Release label: `exp-79`

Release date: 2026-05-20

Release state: released experimental vec-i32-transform-helper stdlib gate

### Summary

Glagol exp-79 gates the concrete transform-helper extension for the staged
`std.vec_i32` source-authored facade.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for these helpers:

- `concat`
- `take`
- `drop`
- `reverse`

The helpers are ordinary source-authored recursion over the existing promoted
`std.vec.i32` runtime family and the already staged `std.vec_i32` wrappers for
`empty`, `append`, `len`, and `at`. Glagol adds no new parser, checker,
runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no mutable `(vec i32)` local support, no
capacity or reserve management, no sorting, mapping, filtering, or iterator
APIs, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-78

Release label: `exp-78`

Release date: 2026-05-20

Release state: released experimental cli-local-source-facade stdlib gate

### Summary

Glagol exp-78 gates the Glagol-side local source-authored `cli` facade that
mirrors the existing staged `std.cli` helper surface without widening it.

The release adds `examples/projects/std-layout-local-cli/` with explicit local
`cli.slo`, `process.slo`, and `string.slo` modules plus the matching `main.slo`
consumer, adds focused integration coverage, and extends promotion-gate
inventory/alignment checks for these helpers:

- `arg_text_result`
- `arg_i32_result`
- `arg_i32_or_zero`
- `arg_i32_or`
- `arg_i64_result`
- `arg_i64_or_zero`
- `arg_i64_or`
- `arg_f64_result`
- `arg_f64_or_zero`
- `arg_f64_or`
- `arg_bool_result`
- `arg_bool_or_false`
- `arg_bool_or`

The local fixture stays source-authored and explicit: `main.slo` imports local
`cli`, `cli.slo` imports local `process` and `string`, `process.slo` wraps only
the existing promoted `std.process.arg_result`, and `string.slo` wraps only the
existing promoted concrete parse-result helpers. Glagol adds no new parser,
checker, runtime, formatter, or LLVM semantics for this release.

### Explicit Deferrals

No widened `std.cli` API, no automatic standard-library imports, no compiler-
loaded std source, no automatic standard-library search semantics, no new
compiler-known `std.*` runtime names, no process spawning, exit/status control,
no current-directory APIs, no signal handling, no shell parsing, no
subcommands, no flag or option frameworks, no stable ABI/layout guarantees,
and no beta maturity are included.

## exp-77

Release label: `exp-77`

Release date: 2026-05-20

Release state: released experimental vec-i32-option-query-helper stdlib gate

### Summary

Glagol exp-77 extends the concrete `(vec i32)` source-authored collection
facade in the staged `std.vec_i32` module with option-returning query helpers.

The release updates the explicit `std-import-vec_i32/` project, updates the
local source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for these helpers:

- `index_option`
- `first_option`
- `last_option`
- `index_of_option`
- `last_index_of_option`

The helpers are ordinary source wrappers and loops over the existing
promoted `std.vec.i32` runtime family plus the existing `(option i32)`
surface. Glagol adds no new parser, checker, runtime, or LLVM semantics for
this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no option
payload families beyond `(option i32)`, no automatic standard-library imports,
no compiler-loaded std source, no new compiler-known `std.*` runtime names, no
capacity or reserve management, no sorting, mapping, filtering, or iterator
APIs, no mutating collection APIs, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-76

Release label: `exp-76`

Release date: 2026-05-20

Release state: released experimental vec-i32-source-helper stdlib gate

### Summary

Glagol exp-76 gates a concrete `(vec i32)` source-authored collection facade
in the staged `std.vec_i32` module.

The release adds the explicit `std-import-vec_i32/` project, adds the local
source-authored `std-layout-local-vec_i32/` fixture, adds focused
integration coverage, and extends promotion-gate inventory and sibling Slovo
alignment checks for these helpers:

- `empty`
- `append`
- `len`
- `at`
- `singleton`
- `append2`
- `append3`
- `pair`
- `triple`
- `is_empty`
- `index_or`
- `first_or`
- `last_or`
- `contains`
- `sum`

The helpers are ordinary source wrappers and loops over the existing
promoted `std.vec.i32` runtime family. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No generic vectors, no vector payload families beyond `(vec i32)`, no
automatic standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no capacity or reserve management, no
sorting, mapping, filtering, or iterator APIs, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-75

Release label: `exp-75`

Release date: 2026-05-20

Release state: released experimental option-constructor stdlib gate

### Summary

Glagol exp-75 gates source-authored concrete option constructors in the
staged `std.option` facade.

The release expands the explicit `std-import-option/` project, updates the
local source-authored `std-layout-local-option/` fixture, and extends focused
integration coverage plus promotion-gate inventory/alignment checks for these
helpers:

- `some_i32`
- `none_i32`

The helpers are ordinary source wrappers over the existing `some` and `none`
forms for the currently promoted `(option i32)` family. Glagol adds no new
parser, checker, runtime, or LLVM semantics for this release.

### Explicit Deferrals

No generic option helpers, no new option payload families, no automatic
standard-library imports, no compiler-loaded std source, no new
compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-74

Release label: `exp-74`

Release date: 2026-05-20

Release state: released experimental result-constructor stdlib gate

### Summary

Glagol exp-74 gates source-authored concrete result constructors in the
staged `std.result` facade.

The release expands the explicit `std-import-result/` project, updates the
local source-authored `std-layout-local-result/` fixture, and extends focused
integration coverage plus promotion-gate inventory/alignment checks for these
helpers:

- `ok_i32`
- `err_i32`
- `ok_i64`
- `err_i64`
- `ok_string`
- `err_string`
- `ok_f64`
- `err_f64`
- `ok_bool`
- `err_bool`

The helpers are ordinary source wrappers over the existing `ok` and `err`
forms for the currently promoted concrete result families. Glagol adds no new
parser, checker, runtime, or LLVM semantics for this release.

### Explicit Deferrals

No generic result helpers, no new result payload families, no richer error
ADTs, no automatic standard-library imports, no compiler-loaded std source,
no new compiler-known `std.*` runtime names, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-73

Release label: `exp-73`

Release date: 2026-05-20

Release state: released experimental io-value-helper stdlib gate

### Summary

Glagol exp-73 gates source-authored value-returning print helpers in the
staged `std.io` facade.

The release expands the explicit `std-import-io/` project, adds the local
source-authored `std-layout-local-io/` fixture plus focused integration
coverage, and extends promotion-gate inventory/alignment checks for these
helpers:

- `print_i32_value`
- `print_i64_value`
- `print_f64_value`
- `print_string_value`
- `print_bool_value`

The helpers are ordinary source wrappers over the existing promoted print
runtime calls. Glagol adds no new parser, checker, runtime, or LLVM semantics
for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
stderr facade helpers, no stdin facade helpers, no line iteration, no prompt
APIs, no terminal control, no binary or streaming IO, no async IO, no new
compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and no
beta maturity are included.

## exp-72

Release label: `exp-72`

Release date: 2026-05-20

Release state: released experimental cli-custom-fallback stdlib gate

### Summary

Glagol exp-72 gates source-authored typed CLI argument custom-fallback
helpers in the staged `std.cli` facade.

The release expands the explicit `std-import-cli/` project, adds focused
integration coverage, and extends promotion-gate inventory/alignment checks
for these helpers:

- `arg_i32_or`
- `arg_i64_or`
- `arg_f64_or`
- `arg_bool_or`

The helpers are ordinary source wrappers over the existing argument lookup
and concrete parse result families. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
process spawning, no exit/status control, no current-directory APIs, no
signal handling, no shell parsing, no subcommands, no richer CLI framework
APIs, no generic configuration helpers, no new compiler-known `std.*` runtime
names, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-71

Release label: `exp-71`

Release date: 2026-05-20

Release state: released experimental process-custom-fallback stdlib gate

### Summary

Glagol exp-71 gates source-authored typed process argument custom-fallback
helpers in the staged `std.process` facade.

The release expands the local source-authored process fixture at
`examples/projects/std-layout-local-process/` with a local `string.slo`
parse wrapper module, expands the explicit `std-import-process/` project,
adds focused integration coverage, and extends promotion-gate
inventory/alignment checks for these helpers:

- `arg_i32_or`
- `arg_i64_or`
- `arg_f64_or`
- `arg_bool_or`

The helpers are ordinary source wrappers over the existing argument lookup
and concrete parse result families. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
process spawning, no exit/status control, no current-directory APIs, no
signal handling, no shell parsing, no subcommands, no richer CLI framework
APIs, no generic configuration helpers, no new compiler-known `std.*` runtime
names, no stable ABI/layout guarantees, and no beta maturity are included.

## exp-70

Release label: `exp-70`

Release date: 2026-05-20

Release state: released experimental fs-custom-fallback stdlib gate

### Summary

Glagol exp-70 gates source-authored typed filesystem read custom-fallback
helpers in the staged `std.fs` facade.

The release expands the local source-authored fs fixture at
`examples/projects/std-layout-local-fs/` with a local `string.slo` parse
wrapper module, expands the explicit `std-import-fs/` project, adds focused
integration coverage, and extends promotion-gate inventory/alignment checks
for these helpers:

- `read_i32_or`
- `read_i64_or`
- `read_f64_or`
- `read_bool_or`

The helpers are ordinary source wrappers over the existing text-read and
concrete parse result families. Glagol adds no new parser, checker, runtime,
or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
binary file APIs, no directory traversal, no streaming file IO, no async file
IO, no typed file writes, no rich host errors, no new compiler-known `std.*`
runtime names, no stable ABI/layout guarantees, and no beta maturity are
included.

## exp-69

Release label: `exp-69`

Release date: 2026-05-20

Release state: released experimental env-custom-fallback stdlib gate

### Summary

Glagol exp-69 gates source-authored typed environment parse custom-fallback
helpers in the staged `std.env` facade.

The release expands the local source-authored env fixture at
`examples/projects/std-layout-local-env/`, expands the explicit
`std-import-env/` project, adds deterministic present/missing/invalid
environment setup to focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `get_i32_or`
- `get_i64_or`
- `get_f64_or`
- `get_bool_or`

The helpers are ordinary source wrappers over the existing environment lookup
and concrete parse result families. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
generic configuration helpers, no environment mutation, no environment
enumeration, no environment writes, no rich host errors, no new
compiler-known `std.*` runtime names, no stable ABI/layout guarantees, and
no beta maturity are included.

## exp-68

Release label: `exp-68`

Release date: 2026-05-20

Release state: released experimental string-custom-fallback stdlib gate

### Summary

Glagol exp-68 gates source-authored typed string parse custom-fallback
helpers in the staged `std.string` facade.

The release expands the local source-authored string fixture at
`examples/projects/std-layout-local-string/`, expands the explicit
`std-import-string/` project, adds focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `parse_i32_or`
- `parse_i64_or`
- `parse_f64_or`
- `parse_bool_or`

The helpers are ordinary source wrappers over the existing concrete parse
result families. Glagol adds no new parser, checker, runtime, or LLVM
semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
generic parse helpers, no whitespace trimming, no case-insensitive bool
parsing, no rich parse errors, no new compiler-known `std.*` runtime names,
no stable ABI/layout guarantees, and no beta maturity are included.

## exp-67

Release label: `exp-67`

Release date: 2026-05-20

Release state: released experimental process-typed stdlib gate

### Summary

Glagol exp-67 gates source-authored typed process argument helpers in the
staged `std.process` facade.

The release expands the local source-authored process fixture at
`examples/projects/std-layout-local-process/` with a local `string.slo`
parse wrapper module, expands the explicit `std-import-process/` project,
adds focused integration coverage, and extends promotion-gate
inventory/alignment checks for these helpers:

- `arg_i32_result`
- `arg_i32_or_zero`
- `arg_i64_result`
- `arg_i64_or_zero`
- `arg_f64_result`
- `arg_f64_or_zero`
- `arg_bool_result`
- `arg_bool_or_false`

The helpers are ordinary source wrappers over the existing argument lookup
and concrete parse result families. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
process spawning, no exit/status control, no current-directory APIs, no
signal handling, no shell parsing, no subcommands, no richer CLI framework
APIs, no rich host errors, no new compiler-known `std.*` runtime names, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-66

Release label: `exp-66`

Release date: 2026-05-20

Release state: released experimental fs-typed-read stdlib gate

### Summary

Glagol exp-66 gates source-authored typed filesystem read helpers in the
staged `std.fs` facade.

The release expands the local source-authored fs fixture at
`examples/projects/std-layout-local-fs/` with a local `string.slo` parse
wrapper module, expands the explicit `std-import-fs/` project, adds focused
integration coverage, and extends promotion-gate inventory/alignment checks
for these helpers:

- `read_i32_result`
- `read_i32_or_zero`
- `read_i64_result`
- `read_i64_or_zero`
- `read_f64_result`
- `read_f64_or_zero`
- `read_bool_result`
- `read_bool_or_false`

The helpers are ordinary source wrappers over the existing text-read and
concrete parse result families. Glagol adds no new parser, checker, runtime,
or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
binary file APIs, no directory traversal, no streaming file IO, no async
file IO, no typed file writes, no rich host errors, no new compiler-known
`std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity
are included.

## exp-65

Release label: `exp-65`

Release date: 2026-05-20

Release state: released experimental env-typed stdlib gate

### Summary

Glagol exp-65 gates source-authored typed environment helpers in the staged
`std.env` facade.

The release expands the local source-authored env fixture at
`examples/projects/std-layout-local-env/` with a local `string.slo` parse
wrapper module, expands the explicit `std-import-env/` project, adds
deterministic present/missing/invalid environment setup to focused
integration coverage, and extends promotion-gate inventory/alignment checks
for these helpers:

- `get_i32_result`
- `get_i32_or_zero`
- `get_i64_result`
- `get_i64_or_zero`
- `get_f64_result`
- `get_f64_or_zero`
- `get_bool_result`
- `get_bool_or_false`

The helpers are ordinary source wrappers over the existing environment lookup
and concrete parse result families. Glagol adds no new parser, checker,
runtime, or LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
environment mutation, no environment enumeration, no environment writes, no
generic configuration helpers, no rich host errors, no new compiler-known
`std.*` runtime names, no stable ABI/layout guarantees, and no beta maturity
are included.

## exp-64

Release label: `exp-64`

Release date: 2026-05-20

Release state: released experimental num-fallback stdlib gate

### Summary

Glagol exp-64 gates source-authored checked conversion fallback helpers in the
staged `std.num` facade.

The release adds a local source-authored num fixture at
`examples/projects/std-layout-local-num/`, expands the explicit
`std-import-num/` project, adds focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `i64_to_i32_or`
- `f64_to_i32_or`
- `f64_to_i64_or`

The helpers are ordinary source wrappers over the existing checked numeric
conversion result families. Glagol adds no new parser, checker, runtime, or
LLVM semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
unchecked narrowing conversions, no saturating conversions, no generic numeric
traits, no new compiler-known `std.*` runtime names, no stable ABI/layout
guarantees, and no beta maturity are included.

## exp-63

Release label: `exp-63`

Release date: 2026-05-20

Release state: released experimental fs-fallback stdlib gate

### Summary

Glagol exp-63 gates source-authored fallback/status helpers in the staged
`std.fs` facade.

The release expands the local source-authored fs fixture at
`examples/projects/std-layout-local-fs/`, expands the explicit
`std-import-fs/` project, adds focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `read_text_or`
- `write_text_ok`

The helpers are ordinary source wrappers over the existing text filesystem
result families. Glagol adds no new parser, checker, runtime, or LLVM
semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
binary file APIs, no directory traversal, no streaming file IO, no async file
IO, no rich host errors, no new compiler-known `std.*` runtime names, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-62

Release label: `exp-62`

Release date: 2026-05-20

Release state: released experimental env-fallback stdlib gate

### Summary

Glagol exp-62 gates source-authored fallback helpers in the staged `std.env`
facade.

The release expands the local source-authored env fixture at
`examples/projects/std-layout-local-env/`, expands the explicit
`std-import-env/` project, adds deterministic present/missing environment
setup to focused integration coverage, and extends promotion-gate
inventory/alignment checks for these helpers:

- `has`
- `get_or`

The helpers are ordinary source wrappers over the existing environment lookup
result family. Glagol adds no new parser, checker, runtime, or LLVM semantics
for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
environment mutation, no environment enumeration, no platform/configuration
APIs, no rich host errors, no new compiler-known `std.*` runtime names, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-61

Release label: `exp-61`

Release date: 2026-05-20

Release state: released experimental process-fallback stdlib gate

### Summary

Glagol exp-61 gates source-authored fallback helpers in the staged
`std.process` facade.

The release adds a local source-authored process fixture at
`examples/projects/std-layout-local-process/`, expands the explicit
`std-import-process/` project, adds focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `arg_or`
- `arg_or_empty`

The helpers are ordinary source wrappers over the existing process argument
result family. Glagol adds no new parser, checker, runtime, or LLVM semantics
for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no shell
parsing, no option/flag parsing, no subcommands, no spawning, no exit/status
control, no rich host errors, no new compiler-known `std.*` runtime names, no
stable ABI/layout guarantees, and no beta maturity are included.

## exp-60

Release label: `exp-60`

Release date: 2026-05-20

Release state: released experimental string-fallback stdlib gate

### Summary

Glagol exp-60 gates source-authored string parse fallback helpers in the
staged `std.string` facade.

The release adds a local source-authored string fixture at
`examples/projects/std-layout-local-string/`, expands the explicit
`std-import-string/` project, adds focused integration coverage, and extends
promotion-gate inventory/alignment checks for these helpers:

- `parse_i32_or_zero`
- `parse_i64_or_zero`
- `parse_f64_or_zero`
- `parse_bool_or_false`

The helpers are ordinary source wrappers over the existing concrete parse
result families. Glagol adds no new parser, checker, runtime, or LLVM
semantics for this release.

### Explicit Deferrals

No automatic standard-library imports, no compiler-loaded std source, no
generic parse helpers, no whitespace trimming, no case-insensitive bool
parsing, no rich parse errors, no new compiler-known `std.*` runtime names,
no stable ABI/layout guarantees, and no beta maturity are included.

## exp-59

Release label: `exp-59`

Release date: 2026-05-20

Release state: released experimental hosted-build optimization and benchmark
publication gate

### Summary

Glagol exp-59 tightens hosted executable builds and refreshes the publication
process around the benchmark evidence.

The release keeps the language surface unchanged, but it now builds hosted
executables through `clang -O2`, lowers immutable numeric locals directly as
SSA values where the current checker/runtime model allows it, updates the
benchmark methodology/writeups, and adds repo-local PDF rendering scripts for
the current whitepaper and compiler manifest.

### Explicit Deferrals

No general optimizer pass pipeline, no benchmark thresholds, no
cross-machine performance claims, no stable ABI/layout guarantees, no broad
SSA lowering for every value family, and no beta maturity are included.

## exp-58

Release label: `exp-58`

Release date: 2026-05-19

Release state: released experimental boolean logic compiler gate

### Summary

Glagol exp-58 gates `and`, `or`, and `not` as boolean logic forms.

The release adds `examples/boolean-logic.slo`, focused integration coverage,
promotion-gate coverage, and sibling Slovo fixture alignment. `and` and `or`
lower through existing `if` semantics and short-circuit.

### Explicit Deferrals

No truthiness, variadic boolean operators, pattern guards, macro expansion,
stable ABI/layout, optimizer guarantees, benchmark thresholds, or beta
maturity are included.

## exp-57

Release label: `exp-57`

Release date: 2026-05-19

Release state: released experimental integer bitwise compiler/stdlib gate

### Summary

Glagol exp-57 gates `bit_and`, `bit_or`, and `bit_xor` for same-width `i32`
and `i64` operands.

The release adds `examples/integer-bitwise.slo`, focused integration
coverage, promotion-gate coverage, and expanded `std.math` project coverage
for `bit_and_i32`, `bit_or_i32`, `bit_xor_i32`, `bit_and_i64`,
`bit_or_i64`, and `bit_xor_i64`.

### Explicit Deferrals

No shifts, bit-not, unsigned arithmetic, bit-width-specific integer families,
floating-point bitwise operations, generic math, mixed numeric arithmetic,
stable ABI/layout, optimizer guarantees, benchmark thresholds, or beta
maturity are included.

## exp-56

Release label: `exp-56`

Release date: 2026-05-19

Release state: released experimental integer remainder compiler/stdlib gate

### Summary

Glagol exp-56 gates `%` as signed integer remainder for same-width `i32` and
`i64` operands.

The release adds `examples/integer-remainder.slo`, focused integration
coverage, promotion-gate coverage, and expanded `std.math` project coverage
for `rem_i32`, `is_even_i32`, `is_odd_i32`, `rem_i64`, `is_even_i64`, and
`is_odd_i64`.

### Explicit Deferrals

No floating-point remainder, Euclidean modulo, unsigned arithmetic, bit
operations, generic math, mixed numeric arithmetic, stable ABI/layout,
optimizer guarantees, benchmark thresholds, or beta maturity are included.

## exp-55

Release label: `exp-55`

Release date: 2026-05-19

Release state: released experimental f64/bool result source-flow gate

### Summary

Glagol exp-55 gates source constructors and source `match` payload bindings
for `(result f64 i32)` and `(result bool i32)`.

The release adds `examples/result-f64-bool-match.slo`, focused integration
coverage, and updated `std.cli` coverage. The CLI facade now propagates
missing argument indexes as `err 1` for `f64` and `bool` helpers instead of
using trap-based argument lookup.

### Explicit Deferrals

No generic result types, result payload families beyond the already promoted
concrete families, generic `map`/`and_then`, exception handling, automatic
standard-library imports, stable ABI/layout/ownership, optimizer guarantees,
benchmark thresholds, or beta maturity are included.

## exp-54

Release label: `exp-54`

Release date: 2026-05-19

Release state: released experimental typed CLI facade gate

### Summary

Glagol exp-54 gates the expanded `std.cli` source facade with typed argument
parse helpers for `i64`, `f64`, and `bool`.

The release updates `examples/projects/std-import-cli/`, focused integration
coverage, and promotion-gate coverage. The deterministic fixture checks
missing-index result propagation for the current source-supported `string`,
`i32`, and `i64` result families, while keeping `f64` and `bool`
parse-result helpers compile-gated through the explicit import surface.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, lockfiles, package std dependencies, new compiler-known runtime
names, `err f64 i32` or `err bool i32` source constructors, source `match`
over `(result f64 i32)` or `(result bool i32)`, shell parsing, option/flag
parsing, subcommands, environment-backed configuration, stable CLI framework
APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-53

Release label: `exp-53`

Release date: 2026-05-19

Release state: released experimental CLI-facade standard-source search gate

### Summary

Glagol exp-53 gates explicit project-mode source search for the staged
standard CLI facade module: `std.cli`.

The release adds `examples/projects/std-import-cli/`, focused integration
coverage, and promotion-gate coverage. The fixture imports sibling Slovo
standard source without carrying a local copied module, and the facade
exercises transitive standard-source imports through `std.process` and
`std.string`.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, lockfiles, package std dependencies, new compiler-known runtime
names, shell parsing, option/flag parsing, subcommands, environment-backed
configuration, stable CLI framework APIs, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity are included.

## exp-52

Release label: `exp-52`

Release date: 2026-05-19

Release state: released experimental process-facade standard-source search gate

### Summary

Glagol exp-52 gates explicit project-mode source search for the staged
standard process facade module: `std.process`.

The release adds `examples/projects/std-import-process/`, focused integration
coverage, and promotion-gate coverage. The fixture imports sibling Slovo
standard source without carrying a local copied module.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, lockfiles, package std dependencies, new compiler-known process
runtime names, process spawning, exit/status control, current-directory APIs,
signal handling, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-51

Release label: `exp-51`

Release date: 2026-05-19

Release state: released experimental standard-library path-list discovery gate

### Summary

Glagol exp-51 interprets `SLOVO_STD_PATH` as an ordered OS path list. The
standard-source resolver checks listed roots in order and resolves the first
root containing the requested module file.

This supports layered standard-library development: an override root can
contain only the module under test, while a later root can provide the rest of
the staged standard library.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, lockfiles, package std dependencies, semantic version solving,
stable package manager behavior, broad standard-library APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
maturity are included.

## exp-50

Release label: `exp-50`

Release date: 2026-05-19

Release state: released experimental installed standard-library discovery gate

### Summary

Glagol exp-50 gates installed-toolchain discovery for explicit
standard-source imports. A copied `glagol` binary can find staged Slovo
standard-library modules under executable-relative `../share/slovo/std`
without `SLOVO_STD_PATH` or a sibling checkout.

The resolver now checks candidates per requested module file, so an earlier
partial std root does not mask a later root containing the module.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, lockfiles, package std dependencies, stable install layout
guarantees beyond this alpha candidate, new compiler-known runtime names,
broad standard-library APIs, stable ABI/layout/ownership, optimizer
guarantees, benchmark thresholds, or beta maturity are included.

## exp-49

Release label: `exp-49`

Release date: 2026-05-19

Release state: released experimental io-facade standard-source search gate

### Summary

Glagol exp-49 gates explicit project-mode source search for the staged
standard IO facade module: `std.io`.

The release adds `examples/projects/std-import-io/`, focused integration
coverage, and promotion-gate coverage. The fixture imports sibling Slovo
standard source without carrying a local copied module.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, installed stdlib paths, new compiler-known IO names, formatted
output APIs, stream abstractions, async IO, stable ABI/layout/ownership,
optimizer guarantees, benchmark thresholds, or beta maturity are included.

## exp-48

Release label: `exp-48`

Release date: 2026-05-19

Release state: released experimental core-facade standard-source search gate

### Summary

Glagol exp-48 gates explicit project-mode source search for the staged
standard core facade modules: `std.string` and `std.num`.

The release adds `examples/projects/std-import-string/` and
`examples/projects/std-import-num/`, focused integration coverage, and
promotion-gate coverage. Each fixture imports sibling Slovo standard source
without carrying a local copied module.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, package registry
behavior, installed stdlib paths, generic parse/format APIs, broad numeric
casts, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-47

Release label: `exp-47`

Release date: 2026-05-19

Release state: released experimental host-facade standard-source search gate

### Summary

Glagol exp-47 gates explicit project-mode source search for the staged
standard host facade modules: `std.time`, `std.random`, `std.env`, and
`std.fs`.

The release adds `examples/projects/std-import-time/`,
`examples/projects/std-import-random/`, `examples/projects/std-import-env/`,
and `examples/projects/std-import-fs/`, focused integration coverage, and
promotion-gate coverage. Each fixture imports sibling Slovo standard source
without carrying a local copied module.

### Explicit Deferrals

No automatic standard-library imports, `std.slo` aggregator, workspace
dependency syntax for std, package registry behavior, installed stdlib paths,
broad host APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-46

Release label: `exp-46`

Release date: 2026-05-19

Release state: released experimental workspace standard-source search gate

### Summary

Glagol exp-46 implements explicit standard-library source search inside
workspace packages. Workspace package modules can import `std.<module>` source
modules using the same `SLOVO_STD_PATH` or `lib/std` discovery model
as project mode.

The release adds `examples/workspaces/std-import-option/`, focused integration
coverage, and promotion-gate coverage.

### Explicit Deferrals

No automatic standard-library imports, workspace dependency syntax for std,
package registry behavior, installed toolchain stdlib paths, `std.slo`
aggregator, generic option helpers, broad stdlib APIs, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds, or beta
maturity are included.

## exp-45

Release label: `exp-45`

Release date: 2026-05-19

Release state: released experimental result/option standard-source search gate

### Summary

Glagol exp-45 gates the exp-44 source-search resolver for two additional
staged standard modules: `std.result` and `std.option`.

The release adds `examples/projects/std-import-result/` and
`examples/projects/std-import-option/`, focused integration coverage, and
promotion-gate coverage. Both fixtures import repo-root Slovo standard source
without carrying local `result.slo` or `option.slo` copies.

### Explicit Deferrals

No automatic standard-library imports, workspace/package `std` imports,
package registry behavior, `std.slo` aggregator, glob imports, aliases,
qualified member access, generic result helpers, generic option helpers, broad
stdlib APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-44

Release label: `exp-44`

Release date: 2026-05-19

Release state: released experimental standard-library source-search gate

### Summary

Glagol exp-44 implements project-mode source search for explicit
`std.<module>` imports, starting with `std.math`. A project can now write
`(import std.math (...))` and the compiler loads sibling Slovo
`std/math.slo` source instead of requiring a local copied `math.slo`.

The release adds `examples/projects/std-import-math/`, focused integration
coverage, and promotion-gate coverage. The standard-library root is discovered
through `SLOVO_STD_PATH` or a `lib/std` checkout.

### Explicit Deferrals

No automatic standard-library imports, workspace/package `std` imports,
package registry behavior, `std.slo` aggregator, glob imports, aliases,
qualified member access, compiler-known `std.*` runtime names, broad stdlib
APIs, stable ABI/layout/ownership, optimizer guarantees, benchmark
thresholds, or beta maturity are included.

## exp-43

Release label: `exp-43`

Release date: 2026-05-19

Release state: released experimental technical whitepaper and design-skill
gates

### Summary

Glagol exp-43 publishes `docs/GLAGOL_WHITEPAPER.md`, generated PDF
publication artifacts, a concise compiler manifest, and a repository-local
beta compiler-design skill under `.llm/skills/`.

### Explicit Deferrals

No parser behavior, checker behavior, backend behavior, runtime APIs,
compiler-known `std.*` names, automatic standard-library imports, stable
ABI/layout/ownership, optimizer guarantees, benchmark thresholds,
cross-machine performance claims, package registry behavior, or beta maturity
are included.

## exp-42

Release label: `exp-42`

Release date: 2026-05-19

Release state: released experimental hot-loop benchmark mode gates

### Summary

Glagol exp-42 separates two benchmark meanings in the shared runner:
`cold-process` for one normal startup-inclusive run, and `hot-loop` for a
larger runtime-supplied loop count with total time plus normalized median
time for the base loop count.

The benchmark metadata now records hot-loop counts and checksums. The Slovo
benchmark fixtures accept the runner loop count through process arguments
with stdin fallback, so Slovo can participate in hot-loop mode.

### Explicit Deferrals

No language semantics, compiler optimizations, high-resolution Slovo timing
APIs, stable benchmark thresholds, cross-machine performance claims, stable
ABI/layout/ownership, package registry behavior, hot-runtime benchmark
daemon, or beta maturity are included.

## exp-41

Release label: `exp-41`

Release date: 2026-05-19

Release state: released experimental Lisp benchmark comparison gates

### Summary

Glagol exp-41 extends the local benchmark suite with Common Lisp/SBCL source
slots beside the existing Clojure slots. The benchmark suite includes
`math-loop`, `branch-loop`, and `parse-loop` scaffolds, each with Slovo, C,
Rust, Python, Clojure, and Common Lisp/SBCL source slots where the local
toolchain is available.

The shared runner detects SBCL through `sbcl`, `SBCL`, or `--sbcl`. Benchmark
timing remains cold-process local-machine evidence only: Clojure timings
include JVM and Clojure startup, while Common Lisp timings include SBCL script
startup.

### Explicit Deferrals

No language semantics, compiler optimizations, stable benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, hot-runtime benchmark daemon, or beta maturity are
included.

## exp-40

Release label: `exp-40`

Release date: 2026-05-19

Release state: released experimental benchmark-suite and license gates

### Summary

Glagol exp-40 adds a broader local benchmark suite and project license files.
The benchmark suite includes `math-loop`, `branch-loop`, and `parse-loop`
scaffolds, each with Slovo, C, Rust, Python, and Clojure source slots where
the local toolchain is available.

The shared runner validates deterministic checksums, skips missing toolchains,
and reports local-machine timing comparisons only. Clojure is detected through
`clojure`, `CLOJURE`, or `CLOJURE_JAR`.

Glagol is documented and licensed as `MIT OR Apache-2.0`, matching the Cargo
package metadata. Alpha/beta release criteria are recorded in `.llm/`.

### Explicit Deferrals

No language semantics, compiler optimizations, stable benchmark thresholds,
cross-machine performance claims, stable ABI/layout/ownership, package
registry behavior, or beta maturity are included.

## exp-39

Release label: `exp-39`

Release date: 2026-05-19

Release state: released experimental math-helper and benchmark-scaffold gates

### Summary

Glagol exp-39 implements Standard Math Extensions And Benchmark Scaffold Alpha
on the Glagol side as fixture, documentation, promotion-gate coverage, and a
local benchmark scaffold. It extends
`examples/projects/std-layout-local-math/` so an ordinary project explicitly
imports local `math.slo` helpers for `abs`, `neg`, `min`, `max`, `clamp`,
`square`, `cube`, `is_zero`, `is_positive`, `is_negative`, and inclusive
`in_range` across `i32`, `i64`, and finite `f64`.

It also adds `benchmarks/math-loop/`, with Slovo, C, Rust, and Python
implementations plus a runner for local-machine timing comparisons. The runner
supplies the loop count through stdin, validates a shared checksum, skips
missing toolchains where possible, and reports timing data only as local
evidence.

### Explicit Deferrals

No new compiler-known `std.*` names, automatic std import/search path,
compiler-loaded std source, new numeric primitives, modulo,
trigonometry/sqrt/pow/logarithm APIs, generic math, overloads, traits, mixed
numeric arithmetic, optimizer guarantees, benchmark thresholds, cross-machine
performance claims, runtime ABI changes, stable ABI/layout/ownership, or beta
maturity are included.

## exp-38

Release label: `exp-38`

Release date: 2026-05-19

Release state: released experimental source-facade gates

### Summary

Glagol exp-38 implements Standard Host Source Facades Alpha on the Glagol side
as fixture, documentation, and promotion-gate coverage. It adds
`examples/projects/std-layout-local-random/`,
`examples/projects/std-layout-local-env/`, and
`examples/projects/std-layout-local-fs/` so ordinary projects explicitly
import local facades backed by already promoted `std.random.i32`,
`std.env.get`, `std.env.get_result`, `std.fs.read_text`,
`std.fs.read_text_result`, `std.fs.write_text`, and
`std.fs.write_text_result` calls.

The gated facade set is `random_i32`, `random_i32_non_negative`, `get`,
`get_result`, `read_text`, `read_text_result`, `write_text_status`, and
`write_text_result`.

The default promotion gate checks the local fixtures remain explicit. The
ignored monorepo Slovo std-source gate now also checks sibling
`std/random.slo`, `std/env.slo`, and `std/fs.slo` as part of the exact std
source inventory and facade-name alignment.

### Explicit Deferrals

No new compiler-known `std.*` names, automatic std import/search path,
compiler-loaded std source, seed/range/bytes/float/UUID/crypto random APIs,
environment mutation/enumeration, binary/directory/streaming/async filesystem
APIs, rich host error ADTs, runtime ABI changes, stable ABI/layout/ownership,
or beta maturity are included.

## exp-37

Release label: `exp-37`

Release date: 2026-05-19

Release state: released experimental source-facade gates

### Summary

Glagol exp-37 implements Standard Time Source Facade Alpha on the Glagol side
as fixture, documentation, and promotion-gate coverage. It adds
`examples/projects/std-layout-local-time/` so an ordinary project explicitly
imports local `time.slo` facades backed by the existing promoted
`std.time.monotonic_ms` and `std.time.sleep_ms` calls.

The gated facade set is `monotonic_ms` and `sleep_ms_zero`. `sleep_ms_zero`
calls `std.time.sleep_ms 0` and returns `0`, because source unit-return facade
functions are not promoted.

The default promotion gate checks the local fixture remains explicit. The
ignored monorepo Slovo std-source gate now also checks repo `lib/std/time.slo`
as part of the exact std source inventory and facade-name alignment.

### Explicit Deferrals

No new compiler-known `std.*` names, automatic std import/search path,
compiler-loaded std source, wall-clock/calendar/timezone APIs,
high-resolution timers, async timers, cancellation, scheduling guarantees,
runtime ABI changes, stable ABI/layout/ownership, or beta maturity are
included.

## exp-36

Release label: `exp-36`

Release date: 2026-05-19

Release state: released experimental source-helper gates

### Summary

Glagol exp-36 implements Standard Option Source Helpers Alpha on the Glagol
side as fixture, documentation, and promotion-gate coverage. It adds
`examples/projects/std-layout-local-option/` so an ordinary project explicitly
imports local `option.slo` helpers for source-authored `(option i32)` values
created with `some` and `none`.

The gated helper set is `is_some_i32`, `is_none_i32`, `unwrap_some_i32`, and
`unwrap_or_i32`.

The default promotion gate checks the local fixture remains explicit and
source-authored, with no automatic std imports and no compiler-known
`std.option.*` names. The ignored monorepo Slovo std-source gate now also
checks repo `lib/std/option.slo` inventory and helper-name alignment.

### Explicit Deferrals

No new compiler-known `std.*` names, generic option helpers, option payload
families beyond `i32`, source-loaded std modules, automatic std import/search
path, runtime ABI changes, manifest schema changes, stable ABI/layout/ownership,
or beta maturity are included. exp-95 later broadens the same staged facade
and compiler slice to concrete `(option i64)`.

## exp-35

Release label: `exp-35`

Release date: 2026-05-19

Release state: released experimental source-helper gates

### Summary

Glagol exp-35 implements Standard Result Bool Source Helpers Alpha on the
Glagol side as fixture, documentation, and promotion-gate coverage. It extends
`examples/projects/std-layout-local-result/` so an ordinary project explicitly
imports local `result.slo` helpers for `(result bool i32)` values produced by
`std.string.parse_bool_result`.

The gated helper set is `is_ok_bool`, `is_err_bool`, `unwrap_ok_bool`,
`unwrap_err_bool`, and `unwrap_or_bool`.

The default promotion gate checks the local fixture remains explicit and
source-authored, with no automatic std imports and no compiler-known
`std.result.unwrap_or`. The ignored monorepo Slovo std-source gate now also
checks repo `lib/std/result.slo` bool helper-name alignment.

### Explicit Deferrals

No source-authored `(result bool i32)` constructors, generic bool result
matching, generic result helpers, compiler-known `std.result.unwrap_or`,
`std.result.map`, `std.result.and_then`, option helpers, new compiler-known
`std.*` runtime calls, runtime ABI changes, automatic std import/search path,
compiler-loaded std source, manifest schema changes, stable
ABI/layout/ownership, or beta maturity are included.

## exp-34

Release label: `exp-34`

Release date: 2026-05-19

Release state: released experimental compiler support

### Summary

Glagol exp-34 implements String Parse Bool Result Alpha. The compiler now
promotes exactly
`std.string.parse_bool_result : (string) -> (result bool i32)`.

The release accepts only complete lowercase ASCII `true` and `false`, returns
`ok true` or `ok false`, and returns `err 1` for empty strings,
uppercase/mixed-case text, leading or trailing whitespace, numeric text, or
any other text. Ordinary parse failure does not trap.

The compiler lowers the call through the private runtime helper
`__glagol_string_parse_bool_result`, and the test runner mirrors the same
exact lowercase semantics. The fixture is
`examples/string-parse-bool-result.slo`.

### Explicit Deferrals

No generic parse APIs, trap-based `std.string.parse_bool`, case-insensitive
parsing, whitespace trimming, locale/Unicode parsing, numeric bool parsing,
string/bytes parse APIs, rich parse errors, generic result support,
source-authored `(result bool i32)` constructors or matches, stable helper
ABI/layout/ownership, runtime headers/libraries, manifest schema changes, or
beta maturity are included.

## exp-33

Release label: `exp-33`

Release date: 2026-05-19

Release state: released experimental source-helper gates

### Summary

Glagol exp-33 implements Standard Result Source Helpers Alpha on the Glagol
side as fixture, documentation, and promotion-gate coverage. It adds
`examples/projects/std-layout-local-result/` so an ordinary project explicitly
imports a local `result.slo` module with source-authored helpers over the
current concrete result families.

The gated helper set is `is_err_i64`, `unwrap_err_i64`, `is_err_string`,
`unwrap_err_string`, `is_err_f64`, `unwrap_err_f64`, `unwrap_or_i32`,
`unwrap_or_i64`, `unwrap_or_string`, and `unwrap_or_f64`.

The default promotion gate checks the local fixture remains explicit and
source-authored, with no automatic std imports and no compiler-known
`std.result.unwrap_or`. The ignored monorepo Slovo std-source gate now also
checks repo `lib/std/result.slo` helper-name alignment.

### Explicit Deferrals

No generic result helpers, compiler-known `std.result.unwrap_or`,
`std.result.map`, `std.result.and_then`, option helpers, new result payload
families, new compiler-known `std.*` runtime calls, runtime ABI changes,
automatic std import/search path, compiler-loaded std source, manifest schema
changes, stable ABI/layout/ownership, or beta maturity are included.

## exp-32

Release label: `exp-32`

Release date: 2026-05-19

Release state: released experimental source-helper gates

### Summary

Glagol exp-32 implements Standard Math Source Helpers Alpha on the Glagol side
as fixture, documentation, and promotion-gate coverage. It extends
`examples/projects/std-layout-local-math/` so an ordinary project explicitly
imports a local `math.slo` module with source-authored helpers for the current
`i32`, `i64`, and `f64` numeric families.

The gated helper set is `abs_i32`, `min_i32`, `max_i32`, `clamp_i32`,
`square_i32`, `abs_i64`, `min_i64`, `max_i64`, `clamp_i64`, `square_i64`,
`abs_f64`, `min_f64`, `max_f64`, `clamp_f64`, and `square_f64`.

The default promotion gate checks the local fixture remains explicit and
source-authored, with no `std.*` runtime calls. The ignored monorepo Slovo
std-source gate now also checks repo `lib/std/math.slo` helper-name alignment.

### Explicit Deferrals

No new compiler-known `std.*` runtime calls, runtime ABI changes, automatic
std import/search path, compiler-loaded std source, broad math library,
trigonometry/sqrt/pow, `f32`, unsigned or narrower integer families, generic
math, overloads, traits, mixed numeric arithmetic, manifest schema changes,
stable ABI/layout/ownership, or beta maturity are included.

## exp-31

Release label: `exp-31`

Release date: 2026-05-19

Release state: released experimental compiler support

### Summary

Glagol exp-31 implements Checked F64 To I64 Result Alpha. The compiler now
promotes exactly
`std.num.f64_to_i64_result : (f64) -> (result i64 i32)`.

The call returns `ok value` only when the input is finite, exactly integral,
and inside the signed `i64` range. It returns `err 1` for non-finite,
fractional, or out-of-range input without trapping for ordinary conversion
failure. The implementation executes in the deterministic test runner,
formats through the existing formatter, preserves surface/checked lowering
snapshots, and lowers directly to LLVM with ordered range checks before
`fptosi`.

The promoted fixture is `f64-to-i64-result.slo`.

### Explicit Deferrals

No unchecked `f64` to `i64`, casts or cast syntax, generic `cast_checked`,
`f32`, unsigned or narrower integer families, additional numeric conversion
families, mixed numeric arithmetic, numeric containers, stable ABI/layout,
manifest schema changes, or beta maturity are claimed by this slice.

## exp-30

Release label: `exp-30`

Release date: 2026-05-19

Release state: released experimental contract-gate support

### Summary

Glagol exp-30 implements Standard Library Source Layout Alpha on the compiler
side as documentation and gates for the Slovo `lib/std/` source layout contract.
The expected Slovo contract files are `std/README.md`, `std/io.slo`,
`std/string.slo`, `std/num.slo`, `std/result.slo`, and `std/math.slo`.

Glagol adds `examples/projects/std-layout-local-math/`, a normal project-mode
fixture that explicitly imports a local `math.slo` module. This demonstrates
that the source pattern remains valid for ordinary explicit imports without
claiming automatic standard-library loading.

The ignored promotion gate
`hermeticum_slovo_std_source_layout_alpha_is_preserved` checks the sibling
Slovo `lib/std/` layout plus source-shape and formatter stability.

### Explicit Deferrals

No new source syntax, new compiler-known standard-runtime functions, automatic
`std/` import/search path, package registry behavior, manifest schema changes,
self-hosted replacement for compiler-known `std.*` calls, runtime ABI/layout
claim, or beta maturity is included. Promoted `std.*` calls continue to execute
through `compiler/src/std_runtime.rs`.

## exp-29

Release label: `exp-29`

Release date: 2026-05-19

Release state: released experimental compiler support

### Summary

Glagol exp-29 implements Numeric Struct Fields Alpha. Top-level structs may
use direct immutable `i64` and finite `f64` fields alongside existing direct
`i32`, `bool`, immutable `string`, and current enum fields.

The release covers struct constructors, immutable local/parameter/return/call
flow, field access returning `i64` or `f64`, and use of accessed fields with
existing same-type arithmetic/comparison plus existing print and format
helpers where those helpers are already supported.

The promoted fixture is `numeric-struct-fields.slo`.

### Explicit Deferrals

Struct field mutation, nested structs, arrays/vectors/options/results as
fields, enum payload widening, numeric containers, `f32`, unsigned or narrower
integer families, mixed numeric arithmetic, implicit conversions, new
parse/format APIs, generic structs, methods/traits, stable ABI/layout/
ownership, manifest schema changes, FFI layout claims, and beta maturity
remain outside this slice.

## exp-28

Release label: `exp-28`

Release date: 2026-05-19

Release state: released experimental compiler support

### Summary

Glagol exp-28 implements String Parse F64 Result Alpha. The compiler now
promotes exactly
`std.string.parse_f64_result : (string) -> (result f64 i32)`.

The call accepts complete finite ASCII decimal text in the narrow
`-?digits.digits` shape, returns `ok value` for finite parsed `f64` values,
and returns `err 1` for ordinary parse failure, non-finite text, unsupported
leading/trailing characters, or out-of-domain input. The concrete
`(result f64 i32)` family is supported for direct fixture flow and existing
result helpers without making result handling generic. Source-authored
`(ok f64 i32 ...)`, `(err f64 i32 ...)`, and `match` over
`(result f64 i32)` remain deferred.

The implementation executes in the deterministic test runner, formats through
the existing formatter, preserves surface/checked lowering snapshots, and
lowers hosted builds through private runtime helper
`__glagol_string_parse_f64_result`.

The promoted fixture is `string-parse-f64-result.slo`.

### Explicit Deferrals

No generic parse, trap-based `std.string.parse_f64`, leading `+`, exponent
notation, missing digits around `.`, locale parsing, Unicode digits,
underscores, rich parse errors, stable helper ABI/layout, runtime
headers/libraries, generic result support, f64 containers, mixed numeric
arithmetic, manifest schema changes, or beta maturity are claimed by this
slice.

## exp-27

Release label: `exp-27`

Release date: 2026-05-19

Release state: released experimental compiler support

### Summary

Glagol exp-27 implements Checked F64 To I32 Result Alpha. The compiler now
promotes exactly
`std.num.f64_to_i32_result : (f64) -> (result i32 i32)`.

The call returns `ok value` only when the input is finite, exactly integral,
and inside the signed `i32` range. It returns `err 1` for non-finite,
fractional, or out-of-range input without trapping for ordinary conversion
failure. The implementation executes in the deterministic test runner,
formats through the existing formatter, preserves surface/checked lowering
snapshots, and lowers directly to LLVM with ordered range checks before
`fptosi`.

The promoted fixture is `f64-to-i32-result.slo`.

### Explicit Deferrals

No unchecked `f64` to `i32`, casts or cast syntax, generic `cast_checked`,
`f32`, unsigned or narrower integer families, additional numeric conversion
families, f64 parse, mixed numeric arithmetic, numeric containers, stable
ABI/layout, runtime headers/libraries, manifest schema changes, or beta
maturity are claimed by this slice.

## exp-26

Release label: `exp-26`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-26 implements F64 To String Alpha. The compiler now promotes
exactly `std.num.f64_to_string : (f64) -> string`.

The call returns finite decimal ASCII text for promoted finite `f64` inputs.
It type checks like other promoted standard-runtime names, executes in the
deterministic test runner, formats through the existing formatter, preserves
surface/checked lowering snapshots, lowers hosted builds through a private
runtime helper, and adds machine diagnostic snapshots for arity, type,
context, bool context, standard-name shadowing, and helper-name shadowing.
The promoted fixture is `f64-to-string.slo`.

### Explicit Deferrals

No `f32`, f64 parse, generic format/display/interpolation, locale/base/radix/
grouping/padding/precision controls, stable NaN/infinity text, implicit
conversion, stable helper ABI/layout, runtime headers/libraries, manifest
schema changes, or beta maturity are claimed by this slice.

## exp-25

Release label: `exp-25`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-25 implements String Parse I64 Result Alpha. The compiler now
promotes exactly
`std.string.parse_i64_result : (string) -> (result i64 i32)`.

The call accepts an entire non-empty signed decimal ASCII string, permits only
an optional leading `-`, rejects leading `+`, whitespace, underscores,
base/radix prefixes, locale forms, Unicode digits, suffixes, and trailing
bytes, and returns `ok value` only inside the signed `i64` range. Malformed or
out-of-range inputs return `err 1` without ordinary traps. The promoted
fixture is `string-parse-i64-result.slo`.

The implementation type checks the call, executes it in the deterministic test
runner, formats it through the existing formatter, preserves surface/checked
lowering snapshots, lowers hosted builds through a private runtime helper, and
adds machine diagnostic snapshots for arity, type, context, bool context,
standard-name shadowing, and helper-name shadowing.

### Explicit Deferrals

No leading `+`, whitespace trimming, locale/base/radix/underscore handling,
Unicode digit parsing, f64 parse, bool/string/bytes parse, generic parse, rich
parse errors, stable helper ABI/layout, runtime headers/libraries, manifest
schema changes, or beta maturity are claimed by this slice.

## exp-24

Release label: `exp-24`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-24 implements Integer To String Alpha. The compiler now promotes
exactly `std.num.i32_to_string : (i32) -> string` and
`std.num.i64_to_string : (i64) -> string`.

The calls return signed decimal ASCII strings with a leading `-` for negative
values and no leading `+`. They type check like other promoted
standard-runtime names, execute in the deterministic test runner, format
through the existing formatter, and lower to private runtime helpers that
allocate strings consistently with current string runtime behavior. The
promoted fixture is `integer-to-string.slo`.

### Explicit Deferrals

No f64 formatting, parse APIs, locale/base/radix/grouping/padding controls,
generic display/format traits, implicit conversions, stable helper ABI/layout,
manifest schema changes, or beta maturity are claimed by this slice.

## exp-23

Release label: `exp-23`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-23 implements Checked I64-To-I32 Conversion Alpha. The compiler now
promotes exactly `std.num.i64_to_i32_result : (i64) -> (result i32 i32)`.

The call returns `ok value` for signed `i64` inputs in the signed `i32` range
`[-2147483648, 2147483647]` and `err 1` for out-of-range inputs. It type
checks like other promoted standard-runtime names, executes in the
deterministic test runner, formats through the existing formatter, and lowers
directly to LLVM range checks plus truncation into the existing
`(result i32 i32)` representation. The promoted fixture is
`checked-i64-to-i32-conversion.slo`.

### Explicit Deferrals

No traps, implicit promotion, unchecked narrowing, cast syntax, additional
narrowing conversions, f64 conversions, stable helper ABI/layout, manifest
schema changes, or beta maturity are claimed by this slice.

## exp-22

Release label: `exp-22`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-22 implements Numeric Widening Conversions Alpha. The compiler now
promotes exactly `std.num.i32_to_i64 : (i32) -> i64`,
`std.num.i32_to_f64 : (i32) -> f64`, and
`std.num.i64_to_f64 : (i64) -> f64`.

The calls type check like other promoted standard-runtime names, execute in
the test runner, format through the existing formatter, and lower directly to
LLVM `sext` or `sitofp` conversion instructions. The promoted fixture is
`numeric-widening-conversions.slo`.

### Explicit Deferrals

Implicit promotion, mixed numeric operators, narrowing or checked
conversions, cast syntax, f32, unsigned and narrower integer families,
char/bytes/decimal, numeric parse/format APIs, stable ABI/layout, manifest
schema changes, and beta maturity remain outside this slice.

## exp-21

Release label: `exp-21`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-21 implements I64 Numeric Primitive Alpha. The compiler accepts
direct `i64` type names, explicit signed decimal `i64` suffix atoms,
immutable `i64` locals, parameters, returns, calls, tests, same-type
arithmetic and comparison, LLVM `i64` lowering, and
`std.io.print_i64 : (i64) -> unit`.

The promoted fixture is `i64-numeric-primitive.slo`.

### Explicit Deferrals

f32, unsigned integers, narrower signed integer widths, char/bytes/decimal,
casts, implicit promotion, mixed numeric operators, i64 containers, i64 enum
payloads or struct fields, parse_i64, random i64, stable ABI/layout, manifest
schema changes, and beta maturity remain outside this slice.

## exp-20

Release label: `exp-20`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-20 implements F64 Numeric Primitive Alpha. The language now accepts
direct `f64` type names and float atoms, checks f64 locals, parameters,
returns, calls, top-level tests, arithmetic `+ - * /`, equality, and ordered
comparisons when both operands are `f64`, and emits LLVM `double` value flow.

The standard runtime promotes exactly `std.io.print_f64 : (f64) -> unit`,
lowering to `print_f64(double)` in `runtime/runtime.c` with `%.17g\n`
formatting. The promoted fixture is `f64-numeric-primitive.slo`.

### Explicit Deferrals

f32, i64/u64/u32/u16/u8/i16/i8, char, bytes, decimal, casts, mixed i32/f64
arithmetic or comparison, f64 arrays/vectors/options/results/enum payloads/
struct fields, parse_f64, random floats, stable ABI/layout, manifest schema
changes, and beta maturity remain outside this slice.

## exp-19

Release label: `exp-19`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-19 implements Primitive Struct Fields Alpha. Top-level structs may
use direct `bool` and immutable `string` fields alongside existing direct
`i32` fields and exp-18 direct enum fields.

The slice covers struct construction, field access, immutable struct locals,
parameters, returns, calls, top-level tests, lowering inspection, formatter
stability, and LLVM aggregate emission for direct primitive fields. The
promoted fixture is `primitive-struct-fields.slo`.

### Explicit Deferrals

Arrays, vectors, options, and results containing primitive fields remain
unsupported as struct fields. Nested structs, struct field/value mutation,
broader string ownership and cleanup promises, generics, methods/traits,
stable ABI/layout, manifest schema changes, import/package widening, and beta
maturity remain outside this slice.

## exp-18

Release label: `exp-18`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-18 implements Enum Struct Fields Alpha. Top-level structs may use
current user-defined enum types directly as fields, alongside existing `i32`
fields. This covers payloadless enums and unary `i32` payload enum values in
struct construction, field access, immutable locals, parameters, returns,
calls, same-enum equality, exhaustive enum matches, top-level tests, and
`main`.

The promoted fixture is `enum-struct-fields.slo`, with formatter and lowering
snapshots plus focused diagnostics for enum containers inside struct fields.

### Explicit Deferrals

Arrays, vectors, options, and results containing enums remain unsupported as
struct fields and continue to report `UnsupportedEnumContainer`. Nested struct
fields, struct/enum mutation, printing enum values, enum ordering/hash/
reflection/discriminants, broader enum payloads, generics, stable ABI/layout,
manifest schema changes, package registry behavior, import aliases/globs/
re-exports, and beta maturity remain outside this slice.

## exp-17

Release label: `exp-17`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-17 implements Project/Workspace Enum Imports Alpha. Top-level enum
declarations now participate in flat project and local workspace visibility:
modules can export enum names and consumers can import those enum types
alongside functions and structs.

Imported enums preserve exp-4 payloadless and exp-16 unary `i32` payload
metadata across module and package boundaries. Imported enum values work in
function signatures, immutable locals, calls/returns, qualified constructors,
same-enum equality, exhaustive enum matches, `main`, and tests.

The promoted project fixture is `examples/projects/enum-imports/`.

### Explicit Deferrals

Non-`i32` payload types, multiple payloads, record variants, enum containers,
enum mutation, enum printing, enum ordering/hash/reflection/discriminants,
generics, stable ABI/layout, manifest schema changes, registry/package-manager
behavior, and beta maturity remain outside this slice.

## exp-16

Release label: `exp-16`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-16 implements Unary I32 Enum Payloads Alpha. User enum declarations
may mix payloadless variants with unary `i32` payload variants, for example
`(Value i32)`. Qualified constructors support `(Reading.Missing)` and
`(Reading.Value value)`, and exhaustive enum matches require no binding for
payloadless variants and exactly one immutable arm-local `i32` binding for
payload variants.

Enum values flow through immutable locals, parameters, returns, calls, tests,
`main`, and same-enum equality. Equality compares tag plus payload for payload
enums and tag only for payloadless enums. LLVM and the test runner use a
compiler-owned `{ i32, i32 }` tag/payload representation for payload enums;
this is not a stable ABI or layout claim.

The promoted fixture is `enum-payload-i32.slo`, with formatter and lowering
snapshots plus focused diagnostics for unsupported payload types, constructor
arity/type failures, and match binding requirements.

### Explicit Deferrals

Non-`i32` payload types, multiple payloads, record variants, generic
enums/functions, wildcard/rest/nested enum patterns, pattern guards, enum
values in containers, enum mutation, enum printing, enum ordering/hash/
reflection/discriminants, runtime/runtime.c changes, stable ABI/layout,
manifest schema changes, and beta maturity remain outside this slice.

## exp-15

Release label: `exp-15`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-15 implements Result Helper Standard Names Alpha. It accepts
`std.result.is_ok`, `std.result.is_err`, `std.result.unwrap_ok`, and
`std.result.unwrap_err` for exactly `(result i32 i32)` and
`(result string i32)`, mapping them to the existing result observer and unwrap
behavior.

Legacy `is_ok`, `is_err`, `unwrap_ok`, and `unwrap_err` remain supported.
No `std.result.map`, `std.result.unwrap_or`, `std.result.and_then`, option
standard names, generic results, new result payload families, runtime API,
manifest schema change, or beta maturity is claimed.

## exp-14

Release label: `exp-14`

Release date: 2026-05-18

Release state: released experimental conformance alignment

### Summary

Glagol exp-14 is the Standard Runtime Conformance Alignment release. It aligns
docs, fixtures, formatter/lowering snapshots, promotion inventories, and a
focused conformance gate over the already released exp-13 surface plus released
exp-8 time/sleep support. It is not beta.

This release adds no source syntax, type forms, standard-library operations,
runtime APIs, ABI/layout promises, or manifest schema changes.

### Gate

The focused conformance gate, full release gate, and Slovo/Glagol review pass
together. The new time/sleep fixture uses only `std.time.monotonic_ms` and
`std.time.sleep_ms 0`; it does not assert positive-duration timing behavior.

## exp-13

Release label: `exp-13`

Release date: 2026-05-18

Release state: released experimental compiler support

### Summary

Glagol exp-13 implements Slovo exp-13 String Parse I32 Result Alpha as
released experimental compiler support. It is not beta.

The release promotes exactly one standard-runtime call:

- `std.string.parse_i32_result : (string) -> (result i32 i32)`

The operation parses an entire ASCII decimal signed `i32` string and returns
`ok value` on success or ordinary parse failure as `err 1`.

### Release State

The fixture, diagnostics, lowering snapshots, and promotion inventories are
released experimental compiler-support state after the implementation,
diagnostics, lowering-inspector snapshots, runtime/test-runner behavior,
promotion gates, release review, and full release gate passed.

No trap-based `std.string.parse_i32`, float/bool/string/bytes parsing,
whitespace/locale/base-prefix/underscore/plus-sign parsing, generic parse API,
rich parse errors, Unicode digit parsing, string indexing/slicing,
tokenizer/scanner API, stdin line API, manifest schema changes, stable helper
ABI/layout, runtime headers/libraries, or beta maturity is claimed.

## exp-12

Release label: `exp-12`

Release date: 2026-05-18

### Summary

Glagol exp-12 implements Slovo exp-12 Standard Input Result Alpha as released
experimental compiler support. It is not beta.

The release promotes exactly one standard-runtime call:

- `std.io.read_stdin_result : () -> (result string i32)`

The release returns `ok` with remaining stdin text, including ordinary EOF as
`ok ""`; ordinary host/input failure returns `err 1`.

### Release State

exp-12 is released experimental compiler support after the implementation,
Slovo fixture alignment, formatter, diagnostics, lowering-inspector snapshots,
test-runner, LLVM/runtime, promotion gates, release review, and full release
gate passed.

No trap-based `std.io.read_stdin`, line iteration, prompt APIs, terminal mode,
binary stdin, streaming, async stdin, encoding/Unicode promise, stable helper
ABI/layout, runtime headers/libraries, manifest schema change, or beta maturity
is claimed.

## exp-11

Release label: `exp-11`

Release date: 2026-05-18

### Summary

Glagol exp-11 implements Slovo exp-11 Basic Randomness Alpha. It is released
experimental compiler support, not beta.

The release promotes exactly one standard-runtime call:

- `std.random.i32 : () -> i32`

The call returns a non-negative implementation-owned `i32` suitable only for
basic command-line programs. If native runtime randomness is unavailable, the
runtime trap text must be exactly
`slovo runtime error: random i32 unavailable`.

### Release State

exp-11 is released experimental compiler support after Slovo and Glagol
fixtures, formatter, diagnostics, lowering-inspector snapshots, test-runner,
LLVM/runtime, promotion gates, release review, and release gates passed.

No seed APIs, deterministic public sequences, cryptographic suitability,
range/bounds APIs, bytes, strings, UUIDs, artifact-manifest schema changes,
stable helper ABI, runtime headers/libraries, or beta maturity are claimed.

## exp-10

Release label: `exp-10`

Release date: 2026-05-18

### Summary

Glagol exp-10 implements Slovo exp-10 Result-Based Host Errors Alpha. It is
released experimental compiler support, not beta.

The release promotes exactly one new concrete result family,
`(result string i32)`, and four additive host calls:

- `std.process.arg_result : (i32) -> (result string i32)`
- `std.env.get_result : (string) -> (result string i32)`
- `std.fs.read_text_result : (string) -> (result string i32)`
- `std.fs.write_text_result : (string string) -> (result i32 i32)`

Ordinary host failure returns `err 1`. The exp-3 calls remain unchanged:
argument/read failures still trap, missing environment variables still return
`""`, and writes still return `0` or `1`.

### Release State

exp-10 is released experimental compiler support after formatter, checker,
lowering, diagnostics, test-runner, LLVM/runtime, fixture-alignment, release
review, and release gates passed.

## exp-9

Release label: `exp-9`

Release date: 2026-05-18

### Summary

Glagol exp-9 is the released experimental hardening slice over the released
exp-8 surface. The exp-9 work includes compatibility inventory, migration
guide, source-reachable panic audit, benchmark smoke notes, release gate
evidence, and deterministic hardening tests in
`compiler/tests/reliability_hardening.rs`.

Controller verification has passed the focused exp-9 hardening test and the
full local release gate. Benchmark smoke records structured
`ToolchainUnavailable` for hosted native-build checks because `clang` was not
on PATH in this environment.

exp-9 is hardening-only. It does not add source syntax, type-system behavior,
standard-runtime names, runtime capabilities, package features, manifest schema
versions, stable ABI/layout promises, public performance thresholds, or beta
maturity.

### Release State

exp-9 is released experimental compiler support after matching Slovo and
Glagol gates.

## exp-8

Release label: `exp-8`

Release date: 2026-05-18

### Summary

Glagol exp-8 implements the conservative host time and sleep alpha. It adds
exactly two compiler-known standard-runtime calls:

- `std.time.monotonic_ms : () -> i32`
- `std.time.sleep_ms : (i32) -> unit`

`std.time.monotonic_ms` returns non-negative process-relative host monotonic
elapsed milliseconds, saturating to `i32::MAX`. `std.time.sleep_ms` accepts
non-negative millisecond durations; `0` is valid and deterministic in the test
runner.

### Diagnostics And Limits

Negative sleeps trap as `slovo runtime error: sleep_ms negative duration`.
Hosted runtime failure to read monotonic time traps as
`slovo runtime error: monotonic time unavailable`; non-negative sleep failure
may trap as `slovo runtime error: sleep failed`.

exp-8 adds no source syntax, wall-clock/calendar API, time zones,
high-resolution clock contract, timers, threads, channels, async behavior,
scheduling guarantees, cancellation, or stable helper ABI. The current
artifact manifest has no general standard-runtime usage structure, so exp-8
does not add one-off time metadata.

## exp-7

Release label: `exp-7`

Release date: 2026-05-18

### Summary

Glagol exp-7 implements the experimental test selection and test-run metadata
alpha. `glagol test <file.slo|project> --filter <substring>` and the legacy
single-file `glagol --run-tests --filter <substring> <file.slo>` route select
tests by deterministic, case-sensitive display-name substring matching.

Selected tests execute in existing order. Non-selected discovered tests are
skipped before evaluation and counted as skipped. Zero matches is a successful
run. Text output and artifact manifests expose `total_discovered`, `selected`,
`passed`, `failed`, `skipped`, and optional `filter` metadata.

### Diagnostics And Limits

Missing filter values, repeated `--filter`, and use of `--filter` outside test
mode are command-line diagnostics. The exp-6 C-import test-runner boundary is
unchanged: selected tests that reach imported C calls report
`UnsupportedTestExpression`, while non-selected C-import tests are skipped
before evaluation.

LSP/editor protocols, debug metadata, source maps, SARIF, watch/daemon
behavior, documentation comments, lint categories, benchmark behavior, test
tags/groups/retries/parallelism, and new Slovo source syntax are deferred.
exp-7 is experimental, not beta.

## exp-6

Release label: `exp-6`

Release date: 2026-05-18

### Summary

Glagol exp-6 implements the experimental C FFI scalar imports alpha. It accepts
top-level imports such as:

```slo
(import_c c_add ((lhs i32) (rhs i32)) -> i32)
```

Imported C functions use conservative C symbol names, accept only `i32`
parameters, and return only `i32` or builtin `unit`. Calls to imported C
functions are allowed only inside lexical `(unsafe ...)`; calls outside unsafe
report `UnsafeRequired`.

Native builds lower imports to LLVM external declarations and direct calls.
`glagol build --link-c <path>` links explicit local C source inputs, and
artifact manifests record `foreign_imports` plus `c_link_inputs`.

### Diagnostics And Limits

The interpreter-style test runner does not execute imported C calls in exp-6;
tests that reach a C import report `UnsupportedTestExpression`. Raw unsafe
heads, including `ffi_call`, remain unsupported operations.

Pointers, raw allocation/deallocation, raw unsafe head execution,
ownership/lifetime rules, C exports, callbacks, headers/libraries, broad
linker configuration, and stable ABI/layout are deferred. exp-6 is
experimental, not beta.

## exp-5

Release label: `exp-5`

Release date: 2026-05-18

### Summary

Glagol exp-5 implements the experimental local packages/workspaces alpha. A
workspace `slovo.toml` can declare `[workspace] members`, and each member can
declare `[package] name`, `version`, `source_root`, `entry`, plus local
`[dependencies]` entries such as `mathlib = { path = "../mathlib" }`.

The implemented slice builds a deterministic closed local package graph,
accepts package-qualified imports such as `(import mathlib.math (add_one))`,
checks cross-package visibility through existing module export lists, and
records the workspace/package graph in artifact manifests.

### Diagnostics

The exp-5 diagnostic gate covers missing package manifests or packages,
duplicate package names, dependency cycles, workspace/dependency/source-root
path escapes, invalid package names, invalid package versions, private
cross-package visibility, and dependency key/name mismatches.

### Explicit Deferrals

Registries, lockfiles, semver solving, aliases, globs, re-exports, generated
code, build scripts, publishing, optional/dev/target dependencies, stable
package ABI, and remote dependencies remain outside this experimental slice.
exp-5 is not beta and is not package-manager support.

## exp-4

Release label: `exp-4`

Release date: 2026-05-18

### Summary

Glagol exp-4 implements experimental payloadless user-defined enum support.
Enums can be declared with one or more unique variants, constructed through
qualified constructors such as `(Signal.Red)`, compared for equality when both
operands have the same enum type, passed through immutable locals, parameters,
returns, calls, and top-level tests, and matched exhaustively by variant.

The promoted release fixture is `enum-basic.slo`, byte-aligned with Slovo's
supported fixture. Lowering inspector snapshots cover both surface and checked
enum forms, and diagnostics snapshots cover the exp-4 boundary cases.

### Explicit Deferrals

Payload variants, generic ADTs, type aliases, traits, methods, unqualified
variant constructors, enum mutation, enum printing, enum ordering, enum values
inside containers, stable layout, and stable ABI claims remain outside this
slice. Unqualified variant constructor calls currently report the generic
`UnknownFunction` diagnostic.

### Gates

The exp-4 gate covers Slovo/Glagol fixture equality for `enum-basic.slo`,
formatter and lowering-inspector fixtures, enum LLVM discriminant shape,
top-level enum tests, and golden machine diagnostics for supported boundary
failures.

## exp-3

Release label: `exp-3`

Release date: 2026-05-17

### Summary

Glagol exp-3 implements the conservative standard IO and host-environment
slice. It adds compiler-known standard-runtime functions:

- `std.io.eprint : (string) -> unit`
- `std.process.argc : () -> i32`
- `std.process.arg : (i32) -> string`
- `std.env.get : (string) -> string`
- `std.fs.read_text : (string) -> string`
- `std.fs.write_text : (string string) -> i32`

Missing environment variables return an empty string. `write_text` returns `0`
on success and `1` on host failure. `eprint` writes to stderr without adding a
newline. Native programs initialize a private runtime process view from host
`argc`/`argv`.

Runtime traps are:

- `slovo runtime error: process argument index out of bounds`
- `slovo runtime error: file read failed`

The runtime helper symbols are private implementation details and are reserved
from source/project names. exp-3 does not stabilize host error payloads, file
ownership/lifetime behavior, process layout, runtime ABI, or C helper symbols.

### Explicit Deferrals

Networking, async IO, binary IO, directory traversal, terminal control, stdin
full-read/iteration, time, randomness, result-string host errors, and stable
ABI/layout claims remain outside this slice.

### Gates

The exp-3 gate covers checker diagnostics, lowering-inspector fixtures, LLVM
runtime-call shape, interpreted host behavior where practical, hosted runtime
smoke tests, and trap behavior for process arguments and file reads.

## exp-2

Release label: `exp-2`

Release date: 2026-05-17

### Summary

Glagol exp-2 implements the first collections alpha slice from the Slovo
contract. It adds one concrete growable vector type, `(vec i32)`, plus
compiler-known standard-runtime functions:

- `std.vec.i32.empty : () -> (vec i32)`
- `std.vec.i32.append : ((vec i32), i32) -> (vec i32)`
- `std.vec.i32.len : ((vec i32)) -> i32`
- `std.vec.i32.index : ((vec i32), i32) -> i32`

`append` returns a new immutable runtime-owned vector. `(vec i32)` values can
flow through immutable locals, parameters, returns, calls, top-level tests,
formatter output, lowering inspection, LLVM, runtime C, and the test runner.
Vector equality with `=` compares `(vec i32)` values by length and element
contents.

Runtime traps are:

- `slovo runtime error: vector allocation failed`
- `slovo runtime error: vector index out of bounds`

The runtime helper symbols are private implementation details and are reserved
from source/project names. exp-2 does not stabilize vector layout, C ABI,
allocator behavior, lifetime, destruction, FFI, or ownership semantics.

### Explicit Deferrals

Generic vectors, non-`i32` elements, vector mutation through `var` or `set`,
`push` aliases, nested vectors, vectors inside arrays/structs/options/results,
slices, maps, sets, user-visible allocation/deallocation, and stable layout or
ABI promises remain outside this slice.

### Gates

The exp-2 release gate covers checker diagnostics, formatter stability,
lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner
evaluation, hosted runtime smoke tests, vector trap behavior, allocation-trap
probing, promotion-gate inventory, and Slovo fixture alignment without editing
Slovo fixtures.

## exp-1

Release label: `exp-1`

Release date: 2026-05-17

### Summary

Glagol exp-1 implements the first owned-runtime-string slice from the Slovo
contract. It adds compiler-known `std.string.concat` with signature
`(string, string) -> string`, returning an immutable runtime-owned `string`.
Existing string equality, `std.string.len`, `std.io.print_string`, string
locals, parameters, returns, and calls can use the result.

No legacy `string_concat` alias is accepted. The runtime helper is private
implementation detail, not a stable ABI, layout, allocator, lifetime, or FFI
promise.

### Gates

The exp-1 release gate covered checker diagnostics, formatter stability,
lowering-inspector fixtures, LLVM runtime-call shape, top-level test-runner
evaluation, hosted runtime smoke tests, and Slovo fixture alignment.

## v2.0.0-beta.1

Release tag: `v2.0.0-beta.1`

Release date: 2026-05-17

### Summary

Glagol `v2.0.0-beta.1` is an experimental gate/readiness release over the
completed v1.7 toolchain. It does not add new Slovo source syntax or
semantics. The release documents the current supported surface and proves the
integrated experimental workflow through project scaffolding, `fmt --check`,
`test`, `doc`, and hosted `build` when the host toolchain is available.

### Experimental-Supported Surface

- v1.7 CLI and project tooling, including `new`, `fmt --check`, `fmt --write`,
  `doc`, `test`, and hosted `build`.
- Flat local project mode with explicit imports and exports.
- v1.5 standard-runtime alpha as the basic IO/string subset:
  `std.io.print_i32`, `std.io.print_string`, `std.io.print_bool`, and
  `std.string.len`.
- Fixed-size immutable `i32` arrays as the current collection subset.
- Existing v1.7 language behavior for strings, structs, option/result values,
  exact option/result `match`, and lexical unsafe diagnostics.

### Explicit Deferrals

At tag time, the experimental release deferred vectors and growable
collections, packages and registries, stable ABI/layout, FFI, executable
raw-memory behavior, LSP/watch mode, stable debug metadata, source-map files,
direct machine-code output, and self-hosting until future beta work. The later
`exp-2` slice now implements only the narrow `(vec i32)` collections alpha.

### Release Gates

The experimental gate runs through `scripts/release-gate.sh`: whitespace checks,
`cargo fmt --check`, full `cargo test`, and the ignored promotion, binary, and
LLVM smoke gates. Full `cargo test` includes the v1.7 DX gate and the
experimental workflow proof.

## v1.7

Release tag: `v1.7`

Release date: 2026-05-17

### Summary

Glagol v1.7 is a Developer Experience Hardening release. It adds conservative
tooling around the existing Slovo v1.6 language surface and does not introduce
new Slovo syntax or semantics.

### Tooling Additions

- `glagol new <project-dir> [--name <name>]` scaffolds a minimal project with
  `slovo.toml` and `src/main.slo`.
- `glagol fmt --check <file-or-project>` verifies canonical formatting without
  writes and reports `FormatCheckFailed` when a file would change.
- `glagol fmt --write <file-or-project>` writes canonical formatting in place
  and emits no stdout on success.
- `glagol doc <file-or-project> -o <dir>` writes deterministic Markdown
  documentation to `index.md`.
- `scripts/release-gate.sh` runs the local release gate.

### Explicit Deferrals

v1.7 does not add package management, workspaces, nested modules, import aliases,
semantic reflection, LSP/watch mode, new formatter semantics beyond existing
project syntax, or any new Slovo language behavior.

## v1.6

Release tag: `v1.6`

Release date: 2026-05-17

### Summary

Glagol v1.6 is the Memory And Unsafe Design Slice release. It mirrors Slovo's
conservative v1.6 contract by hardening the reserved unsafe vocabulary and
lexical unsafe diagnostics without promoting executable raw-memory behavior.
The v1.1 through v1.5 sections below are historical release records.

The compiler-known unsafe operation heads are:

- `alloc`
- `dealloc`
- `load`
- `store`
- `ptr_add`
- `unchecked_index`
- `reinterpret`
- `ffi_call`

### Diagnostics And Reservation

Outside lexical `(unsafe ...)`, each unsafe head reports `UnsafeRequired`
before user-function lookup. Inside lexical `(unsafe ...)`, each head reports
`UnsupportedUnsafeOperation`.

These names are reserved from user functions, project imports and exports,
parameters, locals, structs, and match payload bindings where the current
reservation architecture applies. This keeps the vocabulary available for a
future contract without allowing accidental shadowing today.

### Explicit Deferrals

v1.6 does not introduce raw pointers, allocation/deallocation semantics,
pointer load/store, pointer arithmetic, unchecked indexing execution,
reinterpretation, FFI calls, stable ABI/layout promises, runtime C symbols, or
raw-memory LLVM lowering.

### Release Gates

v1.6 verification covers unsafe-required and unsupported-inside-unsafe
diagnostic snapshots for every unsafe head, focused reservation tests for
local source and project visibility paths, existing lexical unsafe formatter
and lowering fixtures, and regressions proving no raw unsafe operation reaches
LLVM lowering.

## v1.5

Release tag: `v1.5`

Release date: 2026-05-17

### Summary

Glagol v1.5 is the Standard Library Alpha release. It mirrors Slovo's
conservative v1.5 contract by promoting stable source-level standard-runtime
names for existing runtime behavior without adding modules, imports, packages,
new IO breadth, allocation, Unicode length semantics, or ABI promises.
The v1.1 through v1.4 sections below are historical release records.

v1.5 promotes:

- `std.io.print_i32`
- `std.io.print_string`
- `std.io.print_bool`
- `std.string.len`

These are compiler-known source-level standard-runtime names. They do not
require imports, do not name user modules, do not create package dependencies,
are not foreign functions, and are not stable C ABI symbols.

Legacy `print_i32`, `print_string`, `print_bool`, and `string_len` remain
compatibility aliases. New examples should prefer the promoted `std.*` names.

### Diagnostics And Deferrals

Unknown or unpromoted `std.*` calls must produce structured diagnostics, with
`UnsupportedStandardLibraryCall` as the suggested code. Arity and type
mismatches use the existing diagnostics where applicable. The exact promoted
`std.*` names are reserved from user function/export shadowing.

v1.5 does not support `std.io.print_unit`, file IO, environment variables,
process arguments, time or clocks, collections, allocation, deallocation,
ownership, user-defined standard modules, imports or packages for
standard-runtime names, overloading, generic standard-library APIs, Unicode
scalar/grapheme/display-width string length, stable C ABI symbols, runtime
layout promises, or FFI contracts.

### Release Gates

v1.5 verification covers parser/lowerer/checker/formatter support
for the promoted `std.*` calls, aligned `examples/standard-runtime.slo` and
`tests/standard-runtime.slo` fixtures, lowering-inspector snapshots, runtime
smoke tests matching legacy stdout and byte-length behavior, diagnostic
snapshots for the v1.5 boundaries, and regressions proving v1.4, v1.3, and
v1.2 behavior remains unchanged.

## v1.4

Release tag: `v1.4`

Release date: 2026-05-17

### Summary

Glagol v1.4 is the Core Language Expansion release. It mirrors Slovo's
conservative source-level `match` contract for existing option/result values
without widening into enums, generics, mutation, vectors, or ABI promises.

- Promotes `match` for exactly `(option i32)` and `(result i32 i32)` subjects.
- Requires exhaustive two-arm forms: `some` and `none` for options, `ok` and
  `err` for results.
- Adds immutable `i32` payload binding for `some`, `ok`, and `err`; payload
  bindings are visible only inside the selected arm body.
- Treats each arm body as an arm-scoped sequential body with one or more
  expressions; the final expression is the arm value.
- Types the `match` expression as the common arm result type.
- Keeps existing `is_some`, `is_none`, `is_ok`, `is_err`, `unwrap_some`,
  `unwrap_ok`, and `unwrap_err` supported, while new examples should prefer
  `match` for payload-dependent option/result control flow.

### Diagnostics And Formatting

The v1.4 diagnostic boundary requires stable codes for match subject type
mismatches, unsupported payload types, non-exhaustive matches, duplicate arms,
malformed patterns, arm result type mismatches, binding collisions, unsupported
mutation, and unsupported option/result container positions.

The formatter target is a canonical multiline `match` shape: the head and
subject stay on the opening line, each arm starts on its own line, pattern
lists stay inline, and body expressions use the normal nested body indentation.
The formatter preserves arm order and does not repair malformed arm sets.

### Deferred From v1.4

- User-defined enums or algebraic data types.
- Generic, non-`i32`, or nested option/result payload matching beyond the
  current v1 limits.
- Options/results inside arrays, structs, or other containers.
- Mutation of option/result values, struct fields, arrays, or vectors.
- `i64` or broader numeric expansion.
- General `(block ...)` expressions outside match arms.
- Pattern guards, wildcard/rest/catch-all patterns, and destructuring.
- Result-oriented standard-library error conventions.
- User-catchable exceptions, ownership, lifetime, layout, or ABI guarantees.

### Release Gates

v1.4 verification covers parser/lowerer/checker/formatter support for the
promoted match surface, fixture alignment with Slovo
`examples/supported/option-result-match.slo`, formatter idempotence for Slovo
`examples/formatter/option-result-match.slo`, lowering-inspector snapshots,
LLVM or runtime smoke tests for arm selection and payload binding, diagnostic
snapshots for every required match code, and regressions proving v1.3 project
mode and v1.2 runtime values remain unchanged.

## v1.3

Release tag: `v1.3`

Release date: 2026-05-17

### Summary

Glagol v1.3 implements Slovo's conservative Project Mode And Modules contract.
The release target is local, manifest-based, flat multi-file projects while
preserving v1.2 single-file `.slo` command behavior.

- Project manifests are named `slovo.toml` and contain `[project]` with
  required `name`, optional `source_root = "src"`, and optional
  `entry = "main"`. `name` is lowercase package-shaped text, `source_root`
  must remain under the project root, `entry` is a flat module identifier, and
  unknown sections or keys are diagnostics.
- `glagol check`, `glagol test`, and `glagol build` enter project mode only
  when given a project root or the `slovo.toml` file itself.
- Project source discovery is limited to immediate `.slo` files under the flat
  source root.
- Modules can declare explicit exports, for example
  `(module math (export add_one Point))`.
- Modules can import explicit exported names, for example
  `(import math (add_one Point))`.
- Project diagnostics preserve multi-file source identity and cover manifest
  failures, missing imports, import cycles, duplicate names, visibility
  failures, ambiguous imports, and unsupported path/module boundaries.
- Project artifact manifests record project roots, manifests, source roots,
  modules, import edges, diagnostics, tests, and build outputs in deterministic
  order.

### Deferred From v1.3

- Packages, package namespaces, dependencies, remote registries, lockfiles, and
  workspaces.
- Import aliases, renames, glob imports, qualified imports, conditional
  imports, and re-exports.
- Nested or hierarchical modules.
- Project formatting, write-in-place formatting, and directory formatting.
- Path escapes from the project root or source root, generated sources, watch
  mode, LSP/editor protocols, and incremental builds.
- Build profiles, target triples, cross-compilation, object/library/header
  outputs, package artifacts, public ABI promises, and stable debug metadata.

### Release Gates

v1.3 verification covers manifest parsing and diagnostics, project
`check`/`test`/`build` command behavior, `examples/projects/basic` fixture
alignment, diagnostic-family checks for import/export failures, deterministic
module-order checks, cross-file related-span checks, project artifact-manifest
snapshots for success and failure paths, and single-file regressions proving
v1.2 mode is unchanged.

## v1.2

Release tag: `v1.2`

Release date: 2026-05-17

### Summary

Glagol v1.2 implements the Slovo v1.2 Practical Runtime Values contract while
preserving the v1.1 single-file CLI/toolchain surface.

- Immutable string value flow through string `let` locals, parameters, returns,
  and calls returning strings.
- String equality through `=`.
- String byte length through temporary compiler/runtime intrinsic `string_len`.
- Boolean printing through temporary compiler/runtime intrinsic `print_bool`.
- Deterministic runtime trap messages and process exit code `1` for array
  bounds failures and option/result unwrap failures.

### Deferred From v1.2

- `print_unit`.
- Mutable strings, string `var` locals, and `set` of string locals.
- String concatenation, indexing, slicing, ownership, allocation/free, and
  stable ABI/layout/FFI promises.
- Strings inside arrays, structs, options, or results.
- Project mode, imports, package management, and multi-file modules.
- Any change to the v1.1 CLI/toolchain surface.

### Release Gates

Final v1.2 verification includes the existing v1.1 gates plus fixture alignment
for `string-value-flow.slo` and `print-bool.slo`, formatter idempotence,
lowering-inspector snapshots, diagnostic snapshots for deferred forms, runtime
smoke tests for strings and traps, and process-exit tests for runtime traps.

## v1.1

Release tag: `v1.1`

Release date: 2026-05-17

## Summary

Glagol v1.1 productizes the hosted single-file toolchain without expanding the
Slovo v1 language surface.

### Canonical Commands

- Added `glagol check <file.slo>` for parse/lower/check/backend-support
  validation with no primary output.
- Added `glagol fmt <file.slo>` as the canonical formatter command.
- Added `glagol test <file.slo>` as the canonical top-level test runner.
- Added `glagol build <file.slo> -o <binary>` for hosted native builds through
  emitted LLVM IR, `runtime/runtime.c`, and Clang.
- Preserved v1 compatibility aliases: default LLVM emission, `--emit=llvm`,
  `--format`, `--print-tree`, `--inspect-lowering=surface`,
  `--inspect-lowering=checked`, `--check-tests`, and `--run-tests`.

### Diagnostics, Manifests, And Exit Codes

- Added `--json-diagnostics` newline-delimited JSON diagnostics using
  `slovo.diagnostic` schema version `1`.
- Added `--no-color` across canonical commands and compatibility modes.
- Extended artifact manifests with command modes, diagnostics encoding,
  no-output check manifests, build output artifacts, and failure manifests when
  `--manifest <path>` has been parsed.
- Implemented the v1.1 exit-code table: `0` success, `1` source/input/test
  failure, `2` usage error, `3` hosted toolchain failure, `4` internal compiler
  error, and `5` manifest or output artifact write failure.

### Hosted Build

- `glagol build` locates Clang through `GLAGOL_CLANG` or `PATH`.
- Missing Clang, missing runtime C, and failed Clang execution are reported as
  toolchain failures with exit code `3`.
- Native output is staged through a temporary file in the destination directory
  before replacing the requested `-o` path on success.
- Project mode, profiles, cross targets, object/library outputs, custom linker
  flags, and stable ABI promises remain deferred.

## v1

Release tag: `v1`

Release date: 2026-05-17

## Summary

Glagol v1 is the compiler release for the Slovo v1 contract. It keeps the
tree-first compiler pipeline visible, expands value flow beyond v0, and hardens
the CLI/tooling surface without claiming direct native executable output.

The default successful primary output remains LLVM IR text. Native execution is
the explicit external workflow: emitted LLVM IR plus `runtime/runtime.c` and
Clang.

### Promoted v1 Value Flow

- Added immutable struct locals, struct parameters, struct returns, calls
  returning structs, and stored field access for the promoted Slovo v1 struct
  slice.
- Added immutable fixed-size `i32` array locals, parameters, returns, calls
  returning arrays, and runtime-checked dynamic indexing with a runtime trap.
- Added option/result value flow for the `i32` subset, including immutable
  option/result locals, parameters, calls returning option/result values, tag
  observation, and explicit payload extraction with trap-based invalid unwraps.
- Added a narrow string runtime slice: direct string literals lower to borrowed
  immutable NUL-terminated static storage as LLVM `ptr`, and the temporary
  `print_string` intrinsic prints one string plus a newline through the runtime.
- Kept full option/result matching, full string value flow, broad runtime
  printing, raw unsafe memory/FFI operations, stable ABI/layout promises, and
  stable debug metadata deferred for the v1 scope freeze.

### CLI Polish

- Added `--emit=llvm` as the explicit spelling for the default LLVM IR emission
  mode.
- Added `-o <path>` to route successful primary output to a file instead of
  stdout.
- Added `--version`, reported from Cargo package metadata.
- Kept stdin source input deferred until source naming and span behavior are
  specified.
- Kept JSON diagnostics and lowering-inspection output deferred until the text
  contract needs a versioned machine-readable companion.

### Slovo v1 Tooling Contract

- Updated machine diagnostics to the Slovo v1 textual schema with root
  `(diagnostic ...)`, `(schema slovo.diagnostic)`, and `(version 1)`.
- Added `--manifest <path>` to write `slovo.artifact-manifest` version `1`
  manifests for successful primary modes and source-diagnostic failures.
- Added `UnsupportedUnitSignatureType` diagnostics for user-written `unit`
  parameter and return signatures while keeping `unit` internal to
  compiler/runtime unit-producing forms.
- Added golden lowering-inspector snapshots for every promoted v1 fixture in
  both surface and checked modes.
- Audited the golden diagnostic matrix and added snapshots for the current
  unsupported string escape, string literal, and bare string expression
  boundaries.
- Kept primary output on stdout or `-o` and diagnostics on stderr; direct native
  executable output remains deferred behind the LLVM-plus-Clang workflow.
- Clarified that artifact manifests are invocation records for textual
  artifacts, not native executable output.

### Formatter And Inspection Stability

- Added the v1 formatter stability contract for supported comments, nested
  promoted forms, and long inline forms.
- Added full-line comment preservation fixtures and structured
  `UnsupportedFormatterComment` rejection for unsupported comment positions,
  including same-line/trailing comments.
- Added golden `--inspect-lowering=surface` and
  `--inspect-lowering=checked` snapshots for every promoted v1 fixture family,
  including formatter comments/stability fixtures accepted by inspector mode.
- Expanded the golden diagnostic matrix for Slovo's required rejected v1
  boundaries: struct duplicate/unknown/mutation shapes, non-`i32`
  option/result signature payloads, and array promoted-flow type mismatches.

### Release Gates

Final v1 verification covers:

```text
cargo test
cargo fmt --check
cargo test --test promotion_gate -- --ignored
cargo test --test binary_smoke -- --ignored
cargo test --test llvm_smoke -- --ignored
git diff --check
```

## v0

Release tag: `v0`

Release date: 2026-05-16

Release commit: `4ccd201`

## Summary

Glagol v0 is the first released compiler for Slovo. It implements the Slovo v0
language contract as a Rust binary CLI that parses, formats, checks, tests,
inspects, lowers, and emits LLVM IR for the supported fixture set.

v0 intentionally keeps the compiler surface small and explicit. The default
output is LLVM IR text; direct executable output remains deferred.

## CLI Surface

Supported v0 commands:

```text
glagol <file.slo>
glagol --format <file.slo>
glagol --print-tree <file.slo>
glagol --inspect-lowering=surface <file.slo>
glagol --inspect-lowering=checked <file.slo>
glagol --check-tests <file.slo>
glagol --run-tests <file.slo>
glagol test <file.slo|project> --filter <substring>
glagol --run-tests --filter <substring> <file.slo>
```

CLI behavior:

- success writes primary output to stdout and exits `0`
- source diagnostics write human and machine diagnostics to stderr and exit `1`
- input/read failures exit `1`
- usage errors exit `2`
- `--help` writes usage information to stderr and exits `0`
- experimental exp-7 test filtering selects by case-sensitive test display-name
  substring, skips non-selected tests before evaluation, and records
  `total_discovered`, `selected`, `passed`, `failed`, `skipped`, and optional
  `filter` metadata in test reports/manifests

## Supported Fixture Set

Glagol v0 supports these compiler fixtures:

```text
examples/add.slo
examples/array.slo
examples/if.slo
examples/local-variables.slo
examples/option-result.slo
examples/struct.slo
examples/unsafe.slo
examples/while.slo
tests/top-level-test.slo
```

These are aligned with Slovo's `examples/supported/` and
`examples/formatter/` fixtures by the ignored monorepo alignment gate.

## Compiler Pipeline

The v0 pipeline is:

```text
.slo source
-> tokens
-> S-expression tree
-> AST
-> typed AST
-> LLVM IR text
```

The compiler keeps source-reachable failures diagnostic-first. Checked source
forms should not reach backend panics.

## Test Coverage

The v0 suite covers:

- supported fixture LLVM shape
- canonical formatter behavior
- parse-tree printing
- surface and checked lowering inspection
- top-level test checking and running
- structured machine diagnostics
- source spans and line/column ranges
- value-producing `if`
- locals and assignment
- `while`
- structs
- arrays and literal indexing
- option/result constructors
- lexical `unsafe`
- CLI usage and exit codes

## Explicit Deferrals

Glagol v0 does not implement:

- direct executable output
- `-o <path>`
- explicit `--emit=llvm`
- stdin source input
- `--version`
- runtime strings
- dynamic array indexing and runtime bounds traps
- complete struct, array, and option/result value flow
- raw memory operations
- FFI
- stable ABI/layout promises
- package management
- direct machine-code backend

## Post-v0 Direction

Post-v0 work starts in `.llm/V1_ROADMAP.md` and should remain locked to Slovo's
`SPEC-v1.md`.

The recommended first compiler slice is struct value flow after Slovo specifies
the v1 contract for struct locals, parameters, returns, and stored field access.