v0.7.2

Kern v0.7.2

Kern v0.7.2 is a library, compiler correctness, and Craft reliability release.

This release continues the pre-1.0 cleanup policy: remove historical baggage
while the language and tooling are still allowed to change, and use standard
library expansion as a way to exercise promised language features more
aggressively.

Highlights

• Expanded base, std, sys, and rt with real Craft.toml manifests and
  README entrypoints, so the bundled libraries are now better aligned with
  Craft's package and documentation model.
• Added a broad standard-library usability pass: generic atomics,
  synchronization helpers, IO adapters, safer filesystem writes, process/env
  helpers, time/terminal conveniences, test diagnostics, collection helpers,
  and range iterators.
• Hardened kernc around method resolution, trait solving, pattern matching,
  const evaluation, atomic lowering, and mutability soundness.
• Improved Craft diagnostics and robustness, especially around lockfile
  auto-management, interrupted command recovery, verbose output, long-running
  operations, and actionable IO errors.
• Added build-script support for compiling C sources through the SDK-owned C
  compiler path.
• Improved LSP and VS Code integration for newer language features and
  toolchain-based server resolution.

Standard Library

std.sync now exposes the long-term generic atomic shape:

• Atomic[T]
• atomic[T](value)
• ordering-based load/store/exchange/compare-and-swap operations
• integer atomic read-modify-write helpers where applicable

Synchronization also gained:

• SpinLock[T] through spin_lock[T](value)
• closure-style with_lock / try_with_lock
• Once through once()

SpinLock[T] intentionally uses closure-based access instead of returning a
guard object. That avoids introducing a copyable guard historical burden before
Kern has a stable move or linear-value model.

std.io gained generic adapters and utilities:

• copy
• copy_n
• LimitReader
• CountingWriter
• NullWriter
• in-memory reader/writer improvements

std.fs gained safer file operations:

• richer file read/write helpers
• path and metadata improvements
• write_all_atomic_tmp
• write_all_atomic

write_all_atomic uses same-directory temporary files, process identifiers,
and bounded collision retries. Windows replacement behavior was aligned with
the public replace-existing contract.

Other library additions include:

• std.proc.process_id()
• expanded environment helpers
• std.time convenience helpers and comparison support
• terminal convenience helpers
• stderr print helpers
• message-bearing test assertions
• option/result test predicates such as assert_some, assert_none,
  assert_ok, and assert_err
• collection length methods
• list/map/tree/slice allocation and mutation helpers
• integer range iterators in base

Compiler And Language

Method calls are more capable and more predictable:

• method lookup can infer impl generics from call arguments
• argument-inferred method lookup was hardened with additional regression tests
• field access and method calls are distinguished more cleanly

Pattern matching and constructor syntax were tightened:

• typed constructor field puns are parsed and checked
• qualified enum value patterns are handled in matching and exhaustiveness
• grouped match value patterns have regression coverage
• structural value patterns lower correctly through scalar leaves
• wildcard coverage proofs short-circuit correctly

Trait solving and soundness received a focused hardening pass:

• false concrete where-clauses are rejected
• open projections no longer use blanket associated-type proofs unsoundly
• projected supertrait vtables are normalized
• immutable trait objects cannot use mutable pointer impls
• projected supertrait proof contracts have regression coverage
• Paterson-style impl prerequisite checks now allow bounded receiver descent

Other compiler fixes:

• generic numeric arguments can default when inferred
• integer literal default documentation was corrected
• const enum optional initializers are supported
• Atomic[bool] lowering uses a byte-sized memory representation where LLVM
  requires it, while keeping the Kern value-side type as bool
• source builds can fall back to host cc
• source-level diagnostics now suggest the mutable subslice syntax when an
  immutable slice is used where mutability is required

Craft

Craft now treats Craft.lock as an automatically managed file.

• craft init creates/syncs Craft.lock
• package-graph commands recreate a missing lockfile
• damaged or partial lockfiles are overwritten with current content
• workspace member commands write the lockfile at the workspace root
• lockfile sync is covered across check, fetch, publish, doc, build,
  install, uninstall, run, and test

The old manual lockfile workflow has been removed rather than preserved as a
compatibility shim. Pre-1.0 Kern should not carry that historical baggage.

Craft UX and diagnostics also improved:

• layered verbose output via repeated -v / named verbose levels
• quieter default command tests and cleaner normal command output
• long-running git fetches are reported
• long-running build actions are reported
• IO failures now include more actionable hints for missing paths,
  permissions, and storage issues
• workspace lock recovery tests were hardened for CI and Windows timing

Build-script and build-pipeline improvements:

• Craft build scripts can compile and link C sources
• SDK-owned C compiler mode was added
• build scripts can stage generated sources, resources, native libraries, and
  post-link artifacts more robustly
• runtime arguments can be passed after -- for craft run and craft test
• release ThinLTO and runtime cache behavior received additional coverage
• package library bundle aliases are preserved correctly

LSP And Editor Tooling

• LSP analysis tracks iterator loops and dirty semantics.
• Open document path lookups are cached.
• Navigation, semantic-token, and document tests were expanded.
• The VS Code extension now resolves kern-lsp from the installed toolchain.

Distribution, CI, And Repository Cleanup

• Windows libxml2 setup in CI was hardened.
• Install scripts and packaged version metadata were updated to 0.7.2.
• The old website build surface was removed from the repository.
• Legacy runtime provider branches were dropped.
• The Rust workspace is clippy-clean with -D warnings.
• Documentation entrypoints were simplified, and the standard-library
  enhancement plan was added as a maintainer-facing tracking document.

Upgrade Notes

• Replace any manual craft lock workflow with normal Craft commands. init,
  check, build, run, test, doc, publish, install, uninstall,
  and fetch now keep Craft.lock current automatically.
• Code relying on historical C-style for loops should move to iterator loops.
• Some previously accepted unsound trait/projection patterns are now rejected.
  This is intentional.
• Pattern syntax around typed constructors and field puns is more complete, but
  also more strictly disambiguated.
• If external automation depended on the removed website/ project, move that
  automation out of the Kern repository checkout.

Verification

The release line was checked with:

cargo test -p craft
cargo clippy -p craft --all-targets -- -D warnings

The broader workspace was also made clippy-clean as part of the 0.7.2 cycle.

Full Changelog: v0.7.1...v0.7.2