Current Status — 0.10.0 pre-launch (product as service)

This is the canonical public implementation-status page for seed. The current language specification is seed/docs/lang-spec.md; its grammar and semantic chapters live under seed/compiler/llvm. A roadmap item is not implemented merely because it is proposed; completed gates require their named closure evidence.

Product 0.10.0 is pre-launch with waitlist 100, playground WASM, and support chatbot on seed-lang.com. grove → catalog, pod → crate-like src|bin with central ~/.seed versioned cache. 1.0 stable has no horizon and no real users yet; service, libs, publish (private), code/binary repo, and per-pod docs are the launch focus.

Gate 47 is complete under the LLVM roadmap. Its 58 dependency-scoped tasks established predictable cold compilation, explicit costs, usable view safety, recoverable task startup and verified incremental reuse. The remaining Linux-only profile rows are explicitly reported as unavailable on macOS; existing diagnostics, tooling and prefix-HIR reuse evidence remains in GATE47_BASELINE.md.

Compiler — 0.10.0

seed/compiler/llvm is the operational repository compiler and launcher. Gates 0-24 are complete for their recorded scopes, as are Gates 26, 29, and 30. Gate 25 (match ergonomics: _ wildcard discard, temporary materialization, ref borrow patterns), Gate 27 (module-qualified module.symbol access), and Gate 31 (floating-point determinism contract) are complete, closed 2026-08-13. Gates 25 and 27 had been recorded complete on 2026-07-29 by a documentation- only commit; verification on 2026-08-13 showed the compiler did not implement their features, they were reopened, and the implementations landed the same day. Gate 28 (structured build output) is complete. Gate 29, ownership analysis scalability for large functions, is complete — ownership on a 4,068-block function dropped from 264s to 1.2s. Gate 30, parallel backend codegen, is complete. Gates 32 (actionable diagnostics), 33 (safe byte write-target), and 34 (fallible spawn) are complete, closed 2026-08-13. Gate 35 (specification critical-path surface: full let type annotations, size_of/align_of compile-time queries, and real link_name with schema-17 interfaces) is complete, closed 2026-08-20. Gate 36 (multiple trait bounds on generic parameters) and Gate 37 (generic impl blocks, impl<t> trait for name<t> with recursive bound satisfaction) are complete, closed 2026-08-20. Gate 38 (residual review findings: irrefutable let patterns, fence-mode overflow hardening, and the backend trust-invariant and grammar alignment documentation) is complete, closed 2026-08-20. Gate 39 (compiler ergonomics and facilitation: shape-aware M007 deduplication of transitively re-exported imports, W900 checked-index unary and C023 double-index desugaring, omitted-bool-field default, array-literal element coercion, and check=build verifier parity) is complete, closed 2026-08-23. The reboot roadmap (Gates 0-39) is fully closed for its recorded scopes; future hardware-enablement work is planned as Gates 40-46. The verified pipeline is:

source → lexer/parser → semantic graph → typed HIR/CFG
       → ownership/provenance/effects/loans → cleanup planning/verification
       → MIR → target layout/ABI → verified low MIR → LLVM

Source imports and .sdi emission execute the same mandatory safety chain. The normal and ASan/UBSan suites pass 1,571 compiler checks (3 skipped: runner-dependent) plus eight unit binaries at the current baseline. Gate-specific evidence is under seed/compiler/llvm/tests/GATE*_BASELINE.md.

Self-hosted compiler

LLVM-backed compiler self-hosting is the active Linux x86-64 track governed by roadmap-self-hosted.md. The operational C23/LLVM compiler remains the default until SH21-05 and a preserved semantic and ABI oracle afterwards.

The October 2 LLVM-first roadmap preserves historical SH0–SH3 evidence while requiring current full-card revalidation. Current reader/writer use schema 22 and the focused interoperability test passes. Finite-origin flow, try_spawn frontend and retained loan components exist; invocation-wide production safety, imported proof preservation and mandatory checked MIR remain open. SH4 is open and SH5 experimental. Current audit differences have named owners.

LLVM emission, S2/S3, full required Linux safety/ABI/workflows, measured budgets and offline recovery are required before SH21-05. LLVM/link/archive tools, source-rebuildable C runtime and reviewed adapters may remain declared product dependencies. Native backend/runtime/linker/tool replacement and SH20 are conditional on a measured SH21-06 decision and explicit activation.

All 101 roadmap cards now have matching manifest dependencies; historical complete labels remain dated evidence, not current closure. Fresh C0 Linux build, normal suite and sanitizer suite pass. M0019–M0021 are repaired: the 100k cold check stays below the unchanged 256 MiB ceiling, retained ownership span checks are present, and spawn MIR agrees across seven cases. SH4 remains open; consult its parity runner and baseline for the current result rather than relying on a copied case count. SH0-01–04 current acceptance has been renewed; SH0-04 was re-captured on the recording host 2026-10-15 at 767e2f1b. The renewed SH0 oracle records C0's S001 rejection of failed-start move/linear capture reuse and the difference between four mock start statuses and production reserve_failed (M0010/M0011), plain scalar task-result transport (M0022), and invalid LLVM for unit-valued local bindings (M0023); these requirements remain open. SH21-01 freezes a 42-row product matrix, three pinned consumers and explicit product/native dependency policies. Its dependency closure passes with six verified current C0/S1 cost groups, all safe profiles, isolated authentication and offline C0 source-rebuild observations. S1 binary emission remains unavailable; these entry measurements do not establish S2/S3 or product recovery. The entry evidence was re-captured and re-frozen 2026-10-12 at 0960f7d3 on the recording host after system-tool drift invalidated the October 3 pins; the roadmap owns final current card status. Later SH21 runners and non-Linux self-hosted ports remain planned.

SH21-01 entry and SH1-01 substrate/bootstrap full-card closure pass; the entry snapshot was re-frozen 2026-10-12 at 0960f7d3, and the October 3 freeze at 6bf41ca9 remains in git history. Entry evidence is preserved as measured inputs: the recorded Git base plus a hash-bound overlay and identified C0 producer reproduce the original source, recipe, consumer and artifact identities. Nine snapshot rejection controls pass in addition to the matrix/stage/cost controls. Later feature source changes do not relabel the initial costs. Current SH0 and implementing-card tests still execute against current sources; this snapshot validates entry observations only. SH1-02 full task closure passes: opt-in cost counters, 100,001-ID deduplication, twenty dynamic findings with checked span decoding, identical diagnostic JSON, three growth-failure families, unchanged budgets and fresh 58-object bootstrap. The C0 rejected-cache dependency-hash leak is repaired and tested with leaks on. Current-host evidence renewal follows the synchronized source/docs fingerprint. SH2-01 closure passes: the try_spawn keyword, stable token code and C0 differential fixtures already existed and the card now has a registered runner. SH2 startup-kind acceptance compares empty, Result-body, nested and missing-brace inputs against C0 and checks markers through AST copy and formatting, with an ordinary-spawn control. The tracked corpus passes with a fresh producer; stale executables and cached interfaces must not be interpreted as source divergences. The SH2-04 runner now rebuilds the producer and executes the full frontend closure, including sanitizers, architecture checks and BF0. Current full-card status belongs to the roadmap and task manifest. SH3-01 now scopes definition identity by owning module so same-spelling nominals in distinct modules stay distinct, and assigns each declaration its DefinitionId once per invocation, with nominal, destructor and signature keys reading that table instead of index arithmetic. Shared multi-module ownership, repeated-path/diamond origins and retained HIR/checked definition metadata now have component evidence. The check path preserves module-scoped aliases, canonical target IDs, spans and export visibility, and collects signatures into an assigned-ID registry over retained ASTs. Signature-only resolution allocates no body facts; unsupported signatures stay pending and return the AST/type owners. Recursive provenance uses assigned IDs, and incomplete production assignments reject. Imported call/body dispatch, full invocation safety and SH3/SH4 closure remain open. SH3-02's transitive import scan is wired into the check path: a cycle reports a located M001, an unknown import reports M002 and a conflicting module binding reports M008, each at the import's line and column with C0's wording, and use "seed.core" stays a no-op as in C0. The self check also aborted on any non-ASCII byte inside a scanned source span: three byte-wise substring scans sliced the text at interior offsets, which str.slice rejects as code-point boundaries. Fixed by comparing bytes instead of slicing; aborts across the 2,643 tracked sources go from 55 to 0 with no verdict regression. The CLI leaf now checks a non-ASCII fixture directly, because the corpus differential drives ast-print and never reached that code. The scans themselves remain as the residual textual heuristics SH4-11 names for deletion, since removing them before the typed-HIR pipeline covers their shapes would drop real diagnostics. Shared imported call/body dispatch is next. S2/S3, full self product safety/workflows/budgets, offline recovery and SH21-05 cutover remain open.

The Linux-native allocator uses precise 16-byte through 8-KiB slab classes, a bounded process-wide empty-slab cache, and unmaps excess empty slabs. box<t> is a single-pointer owner, while ?box<t> uses its audited null niche and therefore also occupies one pointer. Schema-11 .sdi preserves null-niche nominal representation across separate compilation. Gate 18 schema-12 interfaces add exclusive mutable receivers, generic templates, borrowed-return provenance, and fallible application-boundary contracts. Gate 19 schema-13 interfaces add exact target/profile/runtime identity and verified public inline bodies. Gate 20 schema-14 interfaces additionally preserve public immutable scalar, text, tuple, struct, and nested-array constants for source-elided consumers; the compiler emits typed read-only globals and checked projections. Gate 21 has an audited uninitialized-capacity primitive used internally by byte buffers and I/O; io.input_stream provides bounded incremental reads, geometric growth copies only initialized prefixes, and direct spare-capacity I/O is covered by its baseline.

Superseded compiler trees were removed after cutover. Their relevant behavior classifications survive in compiler/llvm/COMPATIBILITY.md and migrated regressions; they do not define current compiler semantics.

Gate status

<!-- generated-gate-ledger:begin -->

<!-- generated-gate-ledger:end -->

Source encoding and text

• .sd source files are UTF-8 by contract.
• string is owned valid UTF-8.
• str is a borrowed read-only UTF-8 pointer-plus-byte-length view.
• String literals have static storage and type str.
• Comments and string contents may contain Unicode.
• len reports byte length. The ordinary text package validates and iterates Unicode scalars allocation-free; grapheme segmentation, normalization, and locale behavior remain library work.
• Source identifiers intentionally remain ASCII: value names use lower snake case, nominal types and variants use UpperCamelCase, and constants are ASCII upper snake case.

The loader validates every source as canonical UTF-8 before lexing and rejects embedded NUL, overlong encodings, surrogates, truncation, and values beyond Unicode's maximum scalar. Decoded string literals are validated as well.

Phase-1 f-string interpolation is implemented for str, borrowed string, bool, and builtin integers. Construction produces ephemeral format_args without heap allocation; direct output uses file.write_*_format, while .to_string()? explicitly materializes an owned string. Phase 2 implements integer base conversion; bounded width/fill/alignment; exact fixed and deterministic scientific/general f32/f64 conversion without libc; and direct static custom formatting through allocation-free borrowed display.display() -> str and debug.debug() -> str implementations.

Implemented language surface

• immutable/mutable/linear bindings and upper-snake constants, whose type annotation is optional: the type is inferred from the initializer, and an initializer that cannot be inferred is rejected with R037 at the declaration;
• functions, implicit-receiver methods, destructors, generics, traits, impls;
• UpperCamelCase structs, enum ADTs, raw unions, arrays, slices, tuples, Option/Result;
• expression-oriented blocks and if/else if/else, if let/while let (both desugared to a two-arm match), plus while, allocation-free for, exhaustive match, break, continue, and early return;
• repeat array literals ([value; count]) that expand a literal value into a fixed array under the expected element type;
• checked indexing for all builtin integer widths; variable-index reads are supported on []u8 function parameters and the original slice from bytes.view(). Scope mutable views within a block and use read-only []u8 function parameters or the original slice for variable-index access;
• explicit unsafe raw memory, atomics, volatile access, address spaces, FFI, syscalls, raw union access, and architecture intrinsics;
• structured spawn, regions, runtime profiles, and separate compilation.
• allocation-free non-escaping closures, explicit fallible boxed closures, inferred callback effects, and schema-16 source-elided callable contracts;
• typed phase-1/2 f-strings with single evaluation, literal-brace escaping, format specifications, static display/debug traits, allocation-free segmented output, and fallible owned materialization.

The clean grammar does not currently implement legacy type-based ADT spellings, lower snake case nominal identifiers, ret/elif and # comments, built-in chan<t>/send/recv, detached spawn, recursive closures, generators, macros, exceptions, async/await, or lifetime syntax.

Ownership and safety

The common model is: copy scalars, move resources, borrow zero-copy views, and clone explicitly. Cleanup runs exactly once on structured exits. Panic, trap, and abort do not unwind or run lexical cleanup/destructors.

Ownership/place/provenance facts propagate through aliases, blocks, branches, loop fixed points, fields/nested fields, known array indexes, tuples, ADTs, option/result, generic aggregates, channels/tasks, function values/indirect calls, parameters/returns, and source-elided .sdi. Dynamic-index moves of resource elements remain rejected.

linear t has exactly-once semantics across those same implemented shapes. @borrow receiver/input-derived views retain provenance without lifetime syntax. Unsafe code assumes explicit raw obligations but does not disable safe ownership of surrounding values.

Plain closures are stack-backed and non-escaping. Captures copy or move in first lexical-use order, remain immutable, and clean exactly once. box |...| explicitly allocates an escaping callable and returns Result<box fn(...) -> T, alloc_error>; boxed callables are move-only, non-cloneable, non-sendable, and region-confined when region allocated. Seed callbacks use one-pointer code/environment descriptors, while platform function pointers remain thin and accept named functions only.

Text, bytes, and regions

• owned string moves; .clone() creates an explicit independent owner;
• bytes is unique mutable binary ownership;
• shared_bytes is a shared read-only handle with explicit retain/clone;
• compatible owner/array views are allocation-free and provenance checked;
• owned conversions return Result<..., alloc_error>;
• region(capacity) { body } provides nested aligned checked bump allocation;
• safe values/views/pointers tied to a region cannot escape it;
• region-bound tasks join before region cleanup.
• str.slice enforces UTF-8 boundaries, while str.equal and ASCII delimiter search remain allocation-free;
• the ordinary text, box, vec, and sort packages provide safe token ranges, recursive ownership, checked mutation, and static ordering.

Concurrency

spawn is structured: task groups drain on every edge leaving their lexical owner before cleanup. Captures copy or move according to capability; sharing is explicit, and cross-task values require send/sync as appropriate.

compiler/llvm/libs/task is an ordinary generic library providing ownership- split channels, typed one-shot task joins, events, cancellation, waitgroups, semaphores, barriers, and locks. The direct spawned-body ABI still returns void, so postfix ? cannot cross the task boundary directly. Gate 15 adds the typed library surface task_result_new, task_result_complete_ok/error, and task_result_wait over the same linear, lexically joined endpoints. Borrowed-endpoint in-place channel operations keep one-shot wrappers whole, so source-elided generic task consumers can carry move-only payloads with user destructors without bypassing exact cleanup. Function values and inferred closures may use @no_runtime_effects fn(...) to require a complete empty runtime-effect summary; unknown unqualified indirect calls remain rejected in restricted profiles. Boxed callbacks cannot cross spawn because they do not provide send.

Libraries and linkage

.sdi interfaces preserve public types, generic templates/common instances, effects, ownership, provenance, destructor, clone, target, build/runtime profile, dependency, and ABI identity. Schema 13 preserves verified inline bodies and body hashes; schema 14 adds verified public recursive immutable constant payloads; schema 15 adds callable effect contracts; schema 16 adds boxed callable signatures, inline closure bodies, and callable representation identity; schema 19 adds origin-qualified nominal and generic-owner identities for order-independent transitive and diamond imports. A library wrapper does not publish an orphan method specialization whose generic method owner comes from an imported package; source-elided consumers rematerialize that instance from the dependency's template. Hosted seed libraries link dynamically by default; --static selects static seed dependencies. Artifact publication is atomic and corrupt, stale-schema, profile-, target-, or ABI-mismatched interfaces fail closed.

The launcher incremental build/run path stages safe packages for typed I/O, process views, integer parsing, portable math, byte buffers, slices, boxes, networking, serialization, tasks, generic collections, and systems wrappers. Gate 18 adds schema-12 @mut vectors and safe benchmark/application consumers; Gate 19 adds schema-13 inline math/system leaves and disjoint slice partitions. These remain ordinary imported packages, not hidden language built-ins.

The Grove network-client foundation now includes owned OpenSSL 3 TLS client/server contexts, bounded streaming HTTP/1.1 GET, and HTTPS with mandatory certificate and hostname/IP verification. Content-length, chunked, and close-delimited bodies share one exact-cleanup incremental owner and can transfer into codec callbacks without buffering the complete payload. macOS ARM64 executes the hermetic TLS/HTTP rows, and their package graphs cross-build for Linux AArch64. The URL parser now exposes bounded borrowed absolute components; fetch composes them through the system IPv4 resolver and follows bounded absolute or relative redirects with dot-segment removal and HTTPS downgrade rejection. One bounded application-supplied Authorization value is accepted only over HTTPS and retained only across same-origin redirects; socket/TLS deadlines remain typed through handshake and body I/O. IPv6/dual-stack selection, bounded resolver cancellation, cookies, decompression, cache policy, authentication-scheme negotiation and credential lifecycle, pooling, public-WAN execution, and physical mobile evidence remain separate.

Registry resolution, lockfiles/download cache, package add/update, cache pruning, documentation generation, LSP, and incremental object/interface cache are implemented by the Gate 15 tooling. Gate 17 stages bare core and ordinary manifest dependencies into profile/target-qualified dynamic stores by default, reuses installed generations without recompilation, and implements transactional user/system seed install plus reference-aware seed uninstall. Explicit --static and --static=all remain independent linkage choices.

Build profiles and performance

--release uses seed-safe-o2-v1; --release-small uses seed-safe-oz-v1. Bounds, discriminant, provenance, ownership, and cleanup guards remain unless LLVM proves them redundant. ThinLTO, PGO, and static linkage are explicit independent options. No operational unchecked profile exists.

Gate 13 compares equivalent numeric, parsing, collection, allocation/string, structured-task, networking, dynamic-call, startup, RSS, and artifact-size workloads against Clang C and Rust. On the closure host, seed remains within the 0-10% ordinary-runtime target for the enforced corpus. This is controlled workload evidence, not a universal claim that every seed program beats C/Rust.

Gate 12's closure-host 100k full-check median is 0.41 s at 177,504 KiB against budgets of 3.00 s and 196,608 KiB. See GATE12_BASELINE.md and GATE13_BASELINE.md for hardware/toolchain metadata and interpretation.

Target status

Object support is not the same as executable hosted support. The canonical matrix is compiler/llvm/tests/GATE14_TARGET_MATRIX.tsv.

Gate 14's required Intel runner, SDK, ABI, FFI, dynamic-library, separate-compilation, corruption, loader, and regression requirements pass. macOS arm64 remains an independently labeled native host rather than a substitute for the Intel closure row.

The Adaptive UI UI9 native-service bridge contract is version 2. It retains bounded 4096-byte UTF-8 clipboard snapshots and adds blocking typed information/warning/error dialogs with 256-byte titles, 2048-byte messages, and platform-neutral acknowledged/cancelled/yes/no results. Headless, native macOS ARM64 AppKit, Linux x86-64 X11, and Windows x86-64/Wine debug/release gates pass. Independent processes prove clipboard exchange; native NSAlert, an owned X11 modal window, and MessageBoxW execute all four response classes with exact close. Rich clipboard formats, file dialogs, Wayland/mobile adapters, and physical Windows remain separate evidence.

The Adaptive UI UI9 plugin host contract is version 4 while the plugin ABI remains version 1. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates retain up to sixteen distinct generation-checked owners, accept up to eight semantic-versioned capabilities with legacy fallback, classify them as numeric or bounded 4096-byte UTF-8 transforms through one complete optional signature group, reject partial catalog/signature groups, duplicate identifiers, capacity overflow, and stale handles, and prove independent exact unload/reopen. Schema-2/3/4/5/6/7 dependency plans additionally retain four Seed-authored plugins simultaneously in dependency-first order, enforce strict exact/caret/tilde semantic-version and capability requirements, skip and count absent optional packages while failing closed on present invalid or incompatible ones, invoke a negotiated numeric capability and a negotiated UTF-8 capability, expose bounded indexed transforms, expose the unique permission union, deny permissioned plans by default, preflight explicit grants before opening any owner, and close in reverse. Schema 6 freezes the declared signature and checks it against the loaded binary before publication; schema 7 freezes bounded permission declarations and grant-aware package policy. These grants do not sandbox native code. Package host contract 3 additionally streams a domain-separated SHA-256 digest over the exact bounded manifest and binary, retains a private read-only POSIX snapshot or a replacement-denying Windows handle, and loads that exact resource. Seed exposes opt-in Ed25519 verification and verified-open operations; independent debug/release fixtures agree on the digest, reject manifest or binary tampering, and prove stable execution after an adversarial source-replacement attempt on macOS, Linux, and Windows/Wine. ui-plugin-trust adds a bounded application-owned publisher/key policy with one active and one overlap key, explicit rotation/revocation, package and repository trusted-open APIs, and whole-dependency-plan preflight. The same three desktop debug/release rows reject missing records, mismatching signatures, and revoked current/rotated keys before activation. Physical Windows, pinned authority-root provisioning/rotation, transparency/timestamp policy, sandboxing, and platform-view composition remain separate evidence.

ui-plugin-trust-store host contract 1 persists the complete bounded application trust policy plus up to eight minimum accepted catalog sequences in one canonical 64-KiB document. It publishes through a private synchronized part file, OS lock, and atomic replacement inside one explicit existing root. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates cover active/overlap/revoked key round-trips, monotonic sequence advancement, rollback and corruption rejection, stale-part recovery, and exact cleanup. ui-plugin-trust-bundle verifies one canonical root-pinned Ed25519 schema-1 policy envelope with bounded authority metadata, freshness, validity, and sequence anti-rollback. ui-plugin-trust-distribution retrieves the envelope only over verified HTTPS. The composed contract loads the durable minimum sequence, replaces the complete policy, advances that sequence, and atomically saves only after successful verification. The same three desktop debug/release rows reject invalid signatures, wrong authority, expiry, replay, HTTP, non-200 responses, and oversized bodies without mutating sequence 8. Authenticated delivery uses the shared HTTPS-only, same-origin credential policy. Envelope GETs use three total attempts with capped 100/200 ms exponential backoff for transport failures and the shared transient HTTP status set. The exact-URL raw-envelope cache fallback is used only for transient fetch failures; every hit repeats root-pinned signature, freshness, validity, and retained-sequence verification, and only an application-verified envelope is stored. Pinned authority-root provisioning/rotation, secure-clock and transparency/timestamp policy, conditional HTTP revalidation, cache expiry/eviction/quota/encryption, Retry-After/jitter policy, authentication-scheme negotiation and credential acquisition/refresh, encryption, sandboxing, and physical Windows remain separate.

The Adaptive UI UI9 plugin generations host contract is version 3. It retains a caller-selected one to eight validated local generations behind the unchanged public active path, reports the contiguous history count, and returns owned semantic-version metadata by tentative inspection. It swaps any selected index through Seed validation. Upgrade commit durably records its retention bound, rotates or prunes fixed slots, and finishes after an interruption only because the exact staged package already passed validation. Tentative rollback recovery restores the prior active bundle. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates cover the full eight-entry bound, selected rollback, pruning, interrupted rotation/publication/rollback, invalid candidates, and normal/interrupted removal of the active bundle plus all history. Remote update discovery and live forced-process/power-loss evidence remain separate.

The initial ui-plugin-update slice now closes bounded, artifact-authenticated explicit-URL updates for permission-free and explicitly granted packages. It composes standard HTTP/HTTPS fetching, canonical archive extraction, caller-selected Ed25519 credentials, trust and permission preflight before native loading, and retained generation publication behind a per-package OS file lock and one synced private part file. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates reject invalid signatures, missing grants, and caller-bound overflows without changing the installed package or history, then publish a valid permissioned update and prove permission-aware rollback. ui-plugin-catalog adds a 64-KiB schema-1/2 catalog with up to 32 bounded releases, order-independent highest-compatible strict-semver selection, a strictly-newer policy, and exact catalog-to-signed-package version binding. Schema 2 authenticates the exact document with a domain-separated detached Ed25519 signature and applies application-selected publisher/key, issue/expiry, clock-tolerance, maximum-validity, and monotonic-sequence anti-rollback policy. The same macOS/Linux/Windows gates cover already-current/no-match behavior plus duplicate, publisher, version-mismatch, invalid-signature, premature, expired, and rollback rejection. Authenticated variants carry one bounded application-selected Authorization value to both catalog and archive requests under the shared HTTPS-only, same-origin redirect policy. Both GETs use three total attempts with capped 100/200 ms exponential backoff for transport failures and the shared transient status set. ui-plugin-remote-cache retains bounded exact-URL raw catalog and archive entries in one explicit root. Only transient fetch failures fall back, and every hit repeats catalog signature/freshness/sequence plus archive, package, version, trust, and permission checks before native loading or publication. Conditional HTTP revalidation, cache expiry/eviction/quota/encryption, Retry-After/jitter policy, authentication-scheme negotiation and credential acquisition/refresh, pinned authority-root provisioning/rotation, transparency/timestamp policy, and physical Windows remain separate.

The shared bounded URL fetcher now passes native macOS/Linux OpenSSL and Windows/Wine WinSock plus WinHTTP/Crypt32 debug/release gates. All three rows preserve the same incremental HTTP body, deadlines, custom-root certificate/hostname verification, bounded relative redirects, and HTTPS downgrade rejection. The authenticated corpus verifies bounded header validation, HTTPS-only use, same-origin forwarding, and cross-origin rejection before credential disclosure. Caller-selected limits provide one to eight total attempts and capped exponential retry/backoff for transport failures and status 408, 425, 429, 500, 502, 503, or 504; the default remains one attempt. IPv6/dual-stack, resolver cancellation, conditional caching, Retry-After/jitter policy, authentication-scheme negotiation and credential lifecycle, pooling, and physical Windows remain separate.

The Adaptive UI UI9 plugin archive host contract is version 3. It retains the strict two-entry schema-1 stored ZIP and schema-2 raw DEFLATE forms and adds a canonical schema-3 raw-LZ4 envelope without a system compression dependency. Native macOS ARM64, Linux x86-64, and Windows x86-64/Wine debug/release gates decode stored, fixed-Huffman, and dynamic-Huffman blocks plus overlapping LZ4 matches; enforce exact compressed input and declared output, CRC, zero padding, a 65,536-block ceiling, manifest/binary/archive bounds, and fixed path-free layout; reject invalid or trailing streams and unsupported or mixed methods; and pass exact package validation, transactional installation/upgrade, schema-1 compatibility, rollback, and cleanup. Remote fetching is provided by the higher-level update and trust-distribution compositions; transparency/timestamp policy remains separate evidence.

CLI and tooling

The repository launcher provides new, check, format, incremental build, run, test, package resolution, install/uninstall, doc, lint, LSP, and publish --check, plus direct compiler flag forwarding and file.sd -o output. Remote registry publication/signing is not implemented; the existing publish command performs local validation only.

The direct compiler formats source, prints semantic/IR forms, emits/reads/hashes .sdi, emits LLVM/object/shared/static/binary artifacts, installs target/ABI- qualified libraries, and executes supported targets. Its executable help is the authoritative flag list:

seed/compiler/llvm/build/seed --help

Documentation source of truth

Historical documents may describe llvm-v1, the v2 prototype, or assembly stub directories that no longer exist. They must be explicitly labeled and must not be used as current clean-language guidance.

Borrowed AST integration (2026-10-15): the HIR template reads an AstModuleView of the resolver-owned module, and body checking returns that same AST owner to the driver. Stage transfer, the real checker and the body loop no longer deep-copy the AST per declaration. Error paths return the original AST for diagnostic span selection, removing the module-level copy. The CLI supplies its parsed root to import scanning with byte/SourceId guards; executed parse counters and transfer controls pass normally and with sanitizers. All-module semantic acceptance remains open. C0 mismatch M0029 was repaired: loan discovery includes view-containing aggregates, and mutation overlap checks protect Copy projections as well as owned values. New aggregate and AST-view controls reject live-owner movement/mutation and local-view escape; separated scopes and unrelated owners remain usable. This does not close all-module body checking, retained imported summaries or SH3/SH4 acceptance.

Self semantic integration (2026-10-15): invocation context is installed before signature initialization. Concrete imported nominals and body signatures reuse registered TypeIds; qualified and unqualified public calls use shared signatures. Local annotations retain AstTypeIds. Known private imported type annotations reject with retained R002 spans in parameters, returns and local declarations; primary CLI JSON controls match C0. Unsupported generic/layout cases, all-module body checking and SH3/SH4 full acceptance remain open.

Retained source-module integration (2026-10-15): the CLI checks all parsed source modules with their shared signatures and canonical type owner. Checked bodies are retained separately from the source-body count; unsupported bodies grant no CheckedProgram/lowering authority. Imported body failures retain their SourceMap and render at their own source spans. Concrete call/diamond controls and a partial-coverage slice control pass; source/import summary propagation, generic/method coverage and BF1/BF3 remain open.

Assigned generic identity integration (2026-10-15): source function parameters intern by owning DefinitionId and ordinal, retain stable source origins and reuse the registered signature during generic body checking. Growth/failure controls and import orderings with actually renumbered local IDs pass. The fresh-ID component API remains unchanged. Trait-bound-set integration, generic nominal/imported specialization and full SH3-03/SH4 acceptance remain open.

Source bound metadata integration (2026-10-15): the parser retains every + trait-bound span through owned/borrowed/copied ASTs. Source traits have canonical identities; function parameters retain the first trait definition and every additional trait TypeId. Unknown/non-trait/private additional bounds reject with located R013 matching C0 primary JSON. Trait satisfaction/witness checks at generic calls, method dispatch and full SH3-03/SH4 acceptance remain open.

Source witness integration (2026-10-15): the invocation retains indexed trait contracts and requires a completed source impl scan. Local inferred generic calls check every marker bound; complete empty-trait impls provide witnesses and missing witnesses produce located H072. Method/generic impl cases remain unproved. C0 M0030 aligns impl target type-parameter naming with declarations, preserving P042 identity/order rejection; focused oracle controls pass, with full-suite renewal owned by SH0_BASELINE.md. SH3-03/SH4 remain open.

Trait method signature preparation (2026-10-15): the AST preserves signature spans and receiver/effect/unsafe/static-view metadata. An owner-checked context resolves method types in the shared canonical table, caches repeated signatures and recovers AST/type owners on unsupported shapes. Cross-trait method ranges and wrong assignments reject. Production publication and full method impl validation remain open; this API does not seal traits or grant witnesses.

Trait method signature publication (2026-10-15): production collection now publishes supported method descriptors into the invocation's shared contracts. Repeated collection and new resolver contexts reuse their signature IDs and unsafe/static-view flags. Declared and published counts remain separate; an incomplete source method set cannot seal. Known private method types and duplicate names retain the first located R002/R014 finding, matching C0 primary CLI JSON. Unsupported signatures remain pending. Method traits remain unsealed; implementation validation, dictionaries, generic impl matching and full SH3-03/SH4 acceptance remain open.

Concrete source impl signature validation (2026-10-15): after all module signatures publish, concrete borrowed/mutable methods compare receiver, parameters and return types against complete source trait method sets, including imported traits. Undeclared/mismatching methods retain R016/R017 with C0 primary JSON parity. Comparison grants no witness. Deferred impl state survives resealing; owned receivers, generic impls, missing/duplicate methods, body/effect summaries and dictionaries remain open. SH3-03/SH4 are not closed.

Source impl completeness diagnostics (2026-10-15): complete concrete source trait contracts now reject missing required methods with R020 at the complete impl span, including imported traits. Name presence is checked separately from signature support. C0/self CLI primary JSON matches for empty, partial and imported missing-method controls. Traits remain unsealed; duplicate methods, owned receivers, generics and implementation body/dictionary validation remain open. SH3-03/SH4 full acceptance is unchanged.

Duplicate source method diagnostics (2026-10-15): module-scoped registration retains R001 at the second method declaration instead of silently failing. CLI primary JSON matches C0 for impl/inherent/imported duplicates. Duplicate slots stay unassigned and signature collection stops; stage/single-module adapters reject partial registrations. Method bodies, owned receivers, generic impls and dictionary/witness integration remain open; SH3-03/SH4 are not closed.

Owned source receiver integration (2026-10-15): ordinary non-generic struct methods now publish an explicit receiver TypeId and build a non-borrowed HIR parameter. Their supported impl signatures participate in R017 checks. Bodies with builtin scalar fields have focused checked coverage. Resource/view/nested and unsafe-field bodies stay pending until canonical nominal cleanup/capability metadata is complete; destructors remain outside this path. Signatures do not grant body or witness authority. Full SH3-03/SH4 acceptance remains open.

Flat resource receiver cleanup integration (2026-10-15): canonical struct fields can complete once with derived capabilities while preserving TypeIds and stable origins. Supported ordinary owned receivers complete builtin scalar/resource fields during signature collection. Before ownership, HIR materializes every receiver field, including unreferenced fields; retained cleanup controls cover whole-owner discard, partial field movement and complete transfer. Nested/view/ unsafe fields, destructors, captures, additional aggregate bindings and general nominal/imported metadata persistence remain pending. These components do not close SH3/SH4 or authorize a full CheckedProgram.