Programming Language

Nocter

A self-contained systems language built around simplicity, encapsulation, and foolproof design.

Documentation GitHub
/development/releases/v0.5.0.md

Nocter v0.5.0 Release Qualification Record

Purpose

v0.5.0 makes an ordinary Nocter package sufficient for sustained application development. The release adds compiler-owned testing, package-wide editor operations, and the practical standard library surface needed by small command-line applications. It builds on the exact package graph and immutable editor snapshots released in v0.4.0; it does not introduce a second project model.

The released baseline is v0.4.0. Every v0.5.0 phase must preserve its source-owned nocter.nct, exact dependency identity, explicit target selection, and CLI/LSP package-graph parity.

Phase 0 Record: Published-Artifact Audit

Phase 0 completed on 2026-08-06. The published GitHub asset was downloaded into a fresh temporary installation rather than reused from repository dist/. Its SHA-256 digest matched the qualified release asset. With no NOCTER_HOME and a minimal environment, the installed compiler found its own home and passed doctor, locked/offline package check, package build, package run, and direct execution of the generated ARM64 Mach-O image.

No v0.4.1 blocker was found. v0.4.0 remains an immutable released baseline.

Phase 1 Record: Explicit Package Test Targets

Phase 1 completed on 2026-08-06. The public package-target and command contracts are owned by Command Line Interface and Native Testing.

Compiler Boundaries

  • ast and parser own the source shape, spans, duplicate fields, and AST JSON.
  • package::targets owns shared logical entry resolution. A new test-target model owns test identity and selection; CLI code does not interpret manifest strings.
  • driver::test_command owns orchestration. A separate report model owns human/JSON presentation.
  • The existing pipeline owns semantic checking, buildability, lowering, ABI, and native emission. The runner cannot bypass those phases or duplicate executable-entry validation.
  • LSP manifest occurrences, semantic ranges, completion, and definition navigation consume the same typed test target and resolved module identity.

Phase 1 Verification Record

The completed implementation includes parser, formatter, JSON AST, validation, duplicate-name, entry-resolution, package-containment, command parsing, and package-only option coverage. Native integration covers passing, nonzero, fallible failure, trap, compile failure, selection, ordering, continuation, locked/offline operation, cleanup, and the JSON report contract. LSP navigation, semantic ranges, and manifest completion consume the same package target model.

The complete repository verification suite, warnings-denied Clippy, generated public documentation, distributed-home execution without NOCTER_HOME, an optimized local distribution, and a packaged JSON test smoke all pass. The packaged smoke ran one passing and one failing target, reported both in declaration order, and returned aggregate failure without leaving a package artifact.

Phase 2 Record: Native Test Declarations and Assertions

Phase 2 completed on 2026-08-06. It adds compiler-recognized test declarations inside test modules, a trusted runner entry plan, failure-preserving execution, source-backed test names, and a small std/testing assertion surface. It uses the Phase 1 target/report protocol rather than introducing a second command or result model. Public declaration, visibility, assertion, selection, and result behavior is specified only in Native Testing.

Compiler Boundaries

  • Every native declaration is a separate TestRunId { target: TestTargetId, test: DeclarationId }. Each run is lowered to a trusted process entry and executed in its own temporary native process. A trap cannot prevent later tests from running.
  • The backend receives an explicit compiler-owned entry plan. It does not rename declarations, rewrite source text, synthesize an AST main, or discover functions by spelling after semantic analysis.
  • A target-wide parse, resolution, or type error yields one run with test: null. Accepted native declarations yield runs with the exact source test name. Human output may render target::test, but JSON always carries the two identities separately.
  • The runner continues in target declaration order and then source declaration order. Summary counts describe executed runs, not packages or source modules.

Completion Gate

  • parser, AST JSON, formatter, duplicate-name, fixed-contract, and invalid-context coverage
  • compiler-owned entry planning with no source rewriting and per-declaration reachability
  • passing, assertion failure, propagated error, trap, compile failure, filtering, ordering, continuation, output capture, cleanup, human, and JSON integration coverage
  • std/testing success and error payload coverage from a distributed home; its static failure payloads deliberately have no allocation-failure path
  • LSP hover, symbols, semantic ranges, completion, definition, and diagnostics for test declarations
  • complete repository verification and optimized packaged-home native test execution

Phase 2 Verification Record

The implementation uses source-backed TestDeclarationId and TestRunId values from discovery through runner reporting. Entry lowering receives the selected declaration directly, assigns a compiler-private IR target, and leaves backend selection identity-based. It never rewrites source, synthesizes a main, or inserts tests into the callable namespace.

Parser, AST JSON, formatter, duplicate-name validation, fixed-contract typechecking, private/public module boundaries, target and case filtering, declaration order, independent processes, propagated errors, traps, compile failures, continuation, captured output, cleanup, human/JSON reports, distributed std/testing, hover, semantic ranges, symbols, completion, and definition are covered. The legacy test-target main path was removed at the Phase 2 boundary.

Phase 3 Record: Package-wide Editor Index and Refactoring

Phase 3 completed on 2026-08-06. It adds cross-module editor operations without creating a second package graph, declaration model, type inference engine, or mutable editor cache.

Semantic Index

  • Every LSP generation owns one immutable package semantic index beside its analyses and package graph. Independent compile units translate numeric SourceId values into stable package/path/span identities before occurrences are joined.
  • Index roots are the root module and explicit executable and test entries of every package in the exact locked graph. Normal frontend loading follows imports from those roots. No directory walk discovers ambient modules, and public names in an unreferenced file are deliberately absent.
  • The index retains exact declaration/use roles, source text, public function/type exports, and its snapshot generation. Package references therefore include closed reached targets while observing the same open-document overlays as diagnostics.

Refactoring and Source Edits

  • prepareRename and rename use resolver-owned semantic identities rather than spelling. Rename emits versioned changes for open documents and unversioned changes for closed documents, rejects invalid identifiers and top-level collisions, and is atomic across all indexed occurrences.
  • Edit ownership is checked by PackageId, not path containment. A dependency or standard-library declaration is read-only even when a path dependency or package store resides below the source package directory.
  • Automatic import completion reads only indexed public exports and derives paths from same-package modules, direct dependency aliases, or std. Compiler-owned import planning preserves leading documentation and existing import groups. Private and unreachable declarations cannot leak into candidates.
  • Diagnostic quick fixes share source-edit planners with direct compiler tests. Phase 3 handles unresolved imports, missing required interface methods, and missing optional/fallible callable contracts. Generated method bodies use valid never-returning Nocter source so the user receives a type-correct skeleton instead of presentation-only text.
  • Inlay hints are projections of retained binding-type, allocation-effect, and result-provenance facts. Explicit source contracts suppress redundant hints. The protocol layer performs only range and position conversion.

Completion Gate

  • closed-module package references and version-aware multi-file rename
  • invalid-name, top-level collision, dependency ownership, and exact identifier-range rejection
  • public/reachable automatic import candidates with documentation-safe edits
  • reparsable import, interface-member, optional-result, and fallible-result edits
  • inferred-type, allocation-effect, and result-provenance hints from shared facts
  • request validation and advertised capabilities for references, rename, code actions, and hints
  • complete repository verification, generated public documentation, warnings-denied Clippy, and an optimized packaged-home LSP smoke without NOCTER_HOME

The index remains snapshot state rather than a mutable side cache. Future incremental work may reuse immutable partitions, but cannot substitute a different graph or declaration identity.

Phase 3 Verification Record

The complete repository verification script passes compiler, CLI, native backend, package, distributed-home, native-test, example-corpus, formatter, and warnings-denied Clippy coverage. The Phase 3-focused surface includes 2,230 compiler-library tests and 22 JSON-RPC LSP integration tests; the distributed-home suite contains 200 tests and verifies the newly advertised capabilities and an inferred-type hint without NOCTER_HOME.

The public documentation build produces 56 pages from the updated English Markdown. An optimized local distribution passes doctor; its installed compiler advertises rename, quick-fix, and inlay capabilities and returns : i32 from retained facts in a framed LSP smoke. The generated archive contains the compiler, metadata, license notices, and complete distributed standard library.

Phase 4: Practical Standard Library

Phase 4 completed on 2026-08-06. The public API contract is owned by Practical Standard Library.

Every allocating or ownership-transferring API requires success, allocation failure, partial initialization, cleanup, and provenance tests through the Phase 1/Phase 2 test system.

Phase 4 Completion Record

  • one compiler-owned open IR contract serves every file-open mode without API-name dispatch in the backend
  • buffered I/O retains initialization and partial-write state in ordinary owned Nocter values
  • collection, text, numeric, and process operations preserve the existing allocation-context and drop models rather than adding runtime-specific ownership paths
  • iterator terminal and collection operations were audited and already complete in the v0.3.0 Phase 10 Iterator<T> defaults, so Phase 4 did not duplicate them.
  • packaged-home source tests build and run a filesystem-oriented program that reads, creates, rewrites, reopens, appends, parses text, queries process state, and uses buffered output.

Phase 5: Package Authoring and Stabilization

Phase 5 completed on 2026-08-06. Public initialization, graph, test-report, and exit-status behavior is owned by Command Line Interface and Native Testing.

Phase 5 Completion Record

  • initialization templates and file creation are isolated driver responsibilities with create-new writes and rollback on partial package creation
  • graph presentation consumes the exact PackageGraph used elsewhere and uses a read-only loader that cannot request source-lock publication
  • CI output reuses the existing test-report model instead of adding a second result representation
  • CLI and LSP parity remains based on the same package loader, exact target identities, immutable semantic index, and locked/offline graph contract.
  • installed-home acceptance starts from nocter init, runs check/test/run/graph without repository configuration, and retains the Phase 4 filesystem application as the practical std gate.

The final candidate passes the complete compiler verification script: 2,230 library tests, 296 build tests, 449 run tests, 18 package tests, 11 native-test tests, 206 distributed-home tests, 22 LSP protocol tests, seven formatter tests, seven source-corpus tests, and two public-example tests, followed by formatting and warnings-denied Clippy. The optimized archive passes doctor, fresh-package check/test/run/graph in locked offline mode, the filesystem package check, and archive inspection.

The v0.5.0 feature scope is frozen. Publication completed on 2026-08-07.

Publication Qualification Record

Final local publication qualification completed on 2026-08-07 from a clean develop worktree. The complete verification script passed with the counts recorded above. Documentation generation produced 113 pages from 63 Markdown documents and 50 Nocter source files; every local Markdown and generated HTML link passed validation.

The optimized arm64-darwin archive was unpacked into a fresh temporary directory and exercised without NOCTER_HOME, HOME, or repository configuration. Its installed compiler found its own home and passed doctor; a package created by the installed compiler passed locked/offline check, native test, run, graph JSON, and direct execution of the emitted Mach-O image. Both public example packages passed formatter, locked/offline check, build, and native execution through the unpacked home. The packaged LSP advertised its 12 qualified capabilities and completed the initialize/shutdown lifecycle.

Archive inspection confirms one .nocter/ root, complete metadata and standard-library source, matching compiler/home/manifest identity 0.5.0, and an ARM64 Mach-O compiler. The exact qualified upload candidate is dist/nocter-v0.5.0-arm64-darwin.tar.gz, has size 3,254,546 bytes, and has SHA-256 digest 61560090d1be6a802900e254c9666d4b60be9623257f1a62b87c1532b0636aa1. Publication uploaded this exact artifact without replacement.

Post-Publication Audit

Nocter v0.5.0 was published at on 2026-08-07. Annotated tag v0.5.0 identifies release merge aae1f5bf9982637413ed31f436cb651c1c1a1301. GitHub reports the qualified asset name, size, and SHA-256 digest above; the release is neither a draft nor a prerelease.

The asset was downloaded again from its public release URL. Its local SHA-256 digest matched the qualification record. With no NOCTER_HOME, HOME, or repository configuration, the unpacked compiler passed doctor, initialized a fresh package, and passed locked/offline check and native test, run, graph JSON, explicit build, and direct execution of the emitted ARM64 Mach-O image. The publication is complete and no release repair remains.

v0.5.0 Completion Definition

v0.5.0 is complete when a released-home user can create a package, write and isolate Nocter tests, run them with stable human and JSON results, safely rename across the package graph, and build a small filesystem-oriented command-line application using the distributed standard library.

Registries, semantic-version resolution, multi-package workspace membership, async execution, concurrency, runtime interface dispatch, source-level lifetime parameters, and a stable cross-version ABI are not v0.5.0 goals.

All completion criteria are satisfied by the published v0.5.0 release.