Standard Library Inventory

This is the current inventory for shipped std modules. It lists module-level exports and re-exports from lib/std/**/*.zx; methods on exported types are documented in the module-specific pages linked by the module name.

Use the Standard Library page for reader-facing navigation. Use this page when checking the exact public surface, stability label, or internal module inventory.

Stability:

• mvp: current public module; normal source may import this module under the documented contract.
• internal: implementation support for stdlib/compiler code. The compiler rejects imports outside the owning implementation subtree; these modules are not user API.
• experimental: reserved for modules shipped behind an explicit experimental boundary. No current lib/std module is experimental.

Removed modules:

• std.task: removed from the source and SDK surface. Use std.async.

Accepted allocation-domain migration:

• RFC 0058 removes the complete public std.allocator module, Allocator, its raw methods and provider callbacks, allocator-bearing constructors/fields, and ambient replacement. Ordinary std owners use one private built-in domain per runtime instance. AllocError.OutOfMemory moves to the sole canonical identity std.mem.AllocError.OutOfMemory; std.mem gains no public raw allocation API. Special storage domains remain separate nominal resource types with matching cleanup and cannot be adopted as built-in owners.
• The source migration is pending. The inventory table therefore retains the checked-in std.allocator row and current std.mem exports as transitional evidence, while their notes record the accepted target.

Accepted crypto migration:

• RFC 0019 supersedes the crypto rows in the current source inventory below. The target std surface is only std.crypto.random.fill with RandomError.Unavailable, plus std.mem.wipe; algorithms move to the exact-revision external zynx-crypto package. The source deletion and package migration are not yet implemented, so the table continues to record the actual transitional exports rather than pretending they are gone.

Accepted process-argument migration:

• RFC 0021 supersedes the current std.env.args() -> ^[^str] experiment with opaque immutable Args/Arg views and removes std.process.args. That source migration is not yet implemented, so the table below keeps the actual transitional exports and records the target in its notes. RFC 0062 exposes the preserved argument count as the readonly Args.length field, not a method.

Accepted process-environment migration:

• RFC 0024 replaces safe live environment lookup and mutation with one immutable, lossless process-start Variables snapshot. Child processes use exactly Environment.Start or a validated complete Environment.Replace(^EnvironmentVariables); Options.environment never consults the live native environment at spawn time. The table below remains a source inventory and therefore retains the transitional exports until implementation. Its preserved entry count is readonly Variables.length under RFC 0062.

Accepted filesystem-capability migration:

• RFC 0022 removes safe portable env.cwd/chdir, process.cwd/chdir, and fs.cwd. RFC 0023 replaces unanchored relative filesystem access with lossless Path, checked RelativePath/AbsolutePath, Dir capabilities and explicit capability acquisition. RFC 0066 fixes that acquisition as a private executable-root @host let name: fs.Dir in _; loan and removes fs.open_root, MissingRoot, and the named-root registry. RFC 0023 also replaces the empty-string Options.cwd sentinel with WorkingDirectory.Start | Path(^fs.AbsolutePath). RFC 0025 adds streaming, capability-anchored Dir.entries()/Dir.walk() traversal and removes glob policy from core std. The table below remains a source inventory, so it records transitional exports until implementation. RFC 0071 fixes the target file-open vocabulary as FileAccess, OpenDisposition, and their explicit OpenMode product. All fifteen combinations are valid; the five disposition cases map exactly onto the four pre-existing open rights without adding a launch version or right. RFC 0072 adds explicit full-integrity File.sync and namespace Dir.sync, cold Future counterparts, and only the independent open_file.sync/sync_directory rights in frozen-successor launch v3. Unsupported targets fail closed; no publication helper or durability mode is accepted. RFC 0073 adds separate AppendAccess/AppendMode and nominal blocking/asynchronous AppendFile owners. One write is a possibly short, indivisible EOF append with no offset or hidden completion loop; ReadAppend reads the same identity through read_at, while sync remains independent. Launch v4 adds only open_file.append, and uncertified append targets fail closed rather than emulate size plus offset write. RFC 0074 accepts no publication owner or helper, generated staging name, cleanup-on-drop, rollback, recovery transaction, launch right, or v5 schema. Its sole portable same-parent recipe composes caller-chosen CreateNew, an explicit short-write loop, File.sync, drop, path-based rename, and Dir.sync on the exact directory containing both direct-child names. Synchronizing a higher ancestor is insufficient; external name coordination and ambiguous phase recovery remain application policy.

Accepted explicit string-literal migration:

• RFC 0049 makes a hole-free unprefixed literal a static shared str only. The closed ^ literal form is the sole literal construction of ^str: a statically decoded-empty, hole-free form is infallible, while every statically nonempty form and every interpolation reports AllocError. Interpolation requires the ^ prefix, and logical owner capacity counts UTF-8 bytes. These are compiler semantics and add no formatting or literal-construction helper to the public standard library.

Accepted counted-text and borrowed-splitting migration:

• RFC 0061 removes the ptr[size] == 0 and no-interior-NUL guarantees from every str role. Size-aware foreign calls pass pointer plus byte count, while terminated calls require checked std.ffi.CStr construction. RFC 0059 supplies the nominal CStr/^CStr family, bounded lookup, and static c"..." literals; RFC 0061 removes its complete-^str projection. The RFCs remove std.mem.from_cstr because it invented ownership over foreign storage.
• str.split and str.lines become infallible, allocation-free constructors of opaque affine SplitCursor<region Life> and LinesCursor<region Source>. Their sole next operations lend source str views, exhaustion is sticky, and owning materialization remains an explicit clone-and-push loop. A cursor cannot be passed directly to strings.join.

Accepted measurement-vocabulary migration:

• RFC 0062 fixes length as logical cardinality, size as byte extent for text, C strings, files, and byte-sized resources, byte_size for compound byte metadata, capacity as a logical owner/session bound, and count as an explicit traversing or consuming action. Public len is removed without an alias; generated raw foreign bindings and private representation names do not define Zynx API vocabulary.
• A direct readonly field is authoritative stored or maintained state and is exact, total, O(1), allocation-free, and effect-free. Zynx adds no computed properties. MemoryStream therefore exposes readonly length, capacity, and position; its derived remaining and is_empty methods disappear. Buffered wrappers use buffered_length(), while fallible dynamic JSON cardinality uses Value.length().

Accepted exact mutation-vocabulary migration:

• RFC 0064 fixes push for one sequence-tail element, text append for one complete str or rune suffix, positional insert, map association put, non-positional add, end pop, selected remove, resource-retaining clear, and same-kind owner-transfer merge.
• The target has no collection append/extend, delete/erase/take, remove_entry, map/set insert, put_all, or add_all aliases. Domain iter.take, MaybeUninit.take, arithmetic add, filesystem remove, and stream write keep their independent meanings. Group.add, slice append, raw-byte string mutation, and ByteBuffer.append remain transitional or removed surface. Retained JSON Value.put/push names are classified without ratifying the complete mutable-DOM semantics.

Accepted owner-anchored raw-view migration:

• RFC 0053 removes the checked-in two-argument std.mem.slice and @slice_of(ptr, length) false-owner shape. The target exposes only overloaded unsafe std.mem.view(ptr, length, anchor): an ordinary final anchor returns shared [T] in L, while explicit &anchor returns exclusive &[T] in L. The anchor supplies the real region and blocks move, drop, reallocation, and conflicting access while the result lives.
• view requires a valid, aligned, fully initialized, provenance-correct range with the appropriate alias proof. It never creates ^[T] ownership and cannot represent unused capacity or foreign output memory awaiting initialization. Bytes over initialized foreign storage uses the explicit two-step mem.view(..., anchor) then safe bytes.Bytes(view) boundary.

Accepted append-only output migration:

• RFC 0054 adds affine OutputSpan<T> as the only initialization-aware session for the unused tail of ^[T]. output(^self, additional) consumes the owner, reuses capacity or grows at most once, and admits one contiguous initialized suffix. push(&self, ^T) extends that prefix; commit(^self) publishes it and cancel(^self) reverse-drops it and restores the old length. Overflow traps, and dropping an unfinished session destroys the entire owned collection.
• Readonly length, capacity, and remaining describe the new suffix only. Raw output is byte-specific: spare_ptr plus unsafe advance prove a foreign call initialized exactly the advanced prefix. Sync Reader retains ordinary initialized overwrite and adds an &OutputSpan<u8> overload. An async or kernel operation that may retain the output pointer consumes the span until true completion. ByteBuffer and set_len are removed from the target; RFC 0055 separately accepts SDK-internal liveness-blind RawStorage<T> for sparse Arena/HashMap/Set slots; it adds no public inventory symbol.

Accepted single-slot initialization migration:

• RFC 0056 adds std.mem.MaybeUninit<T> for one staged value only. Its single role-directed .ptr property yields *T from shared access and *mut T from explicit exclusive access, without changing state; there is no ptr_mut. Unsafe initialize performs a no-drop move into a caller-proven uninitialized slot, and unsafe take returns exactly one owner from a caller-proven initialized valid slot. Dropping the wrapper never drops a possible payload.
• The target removes std.mem.write_at, read_at, and drop_at without aliases. Ordinary aggregates and literals may contain explicit wrappers, but there is no dedicated raw-range constructor, fresh-allocation retyping via mem.view, range-wide publication/conversion, ownership adoption, uninitialized-buffer API, ArrayBuilder, or generic raw output pointer. Contiguous output remains OutputSpan<T>, sparse core storage remains SDK-internal RawStorage<T>, and completed built-in owner publication remains compiler/SDK-private. There is no ManuallyDrop<T>, forget, leak, or public no-drop wrapper; type-local discard self is a language statement, not a std.mem API, and still drops residual fields. The inventory table below still records the checked-in transitional helpers and absence of MaybeUninit<T> until implementation.

Accepted exact volatile-access migration:

• RFC 0075 adds the ordinary unsafe SDK namespace std.mem.volatile with only load and store. Each name has exactly eight non-generic overloads for i8, u8, i16, u16, i32, u32, i64, and u64; no Boolean, float, pointer, pointer-sized, 128-bit, custom, or aggregate payload is accepted. store returns the ordinary void() value.
• Every dynamically reached operation is exactly one target-certified native same-width volatile access, with no elimination, invention, duplication, merging, splitting, speculative execution, helper call, or emulation. Unsupported targets fail compilation. Ordinary provenance, liveness, alignment, and access authority remain caller obligations; the API creates no MMIO mapping or capability and supplies no atomicity, synchronization, ordinary/atomic ordering, fence, cache/DMA, completion, endian, or device guarantee.
• The public @zynx.volatile.read/write experiment is removed without an alias. Any semantic intrinsic below the SDK wrappers is compiler-private. volatile<T> remains C ABI pointer-qualifier metadata only. The inventory table records the new namespace as an accepted target until implementation.

Accepted host-provided MMIO migration:

• RFC 0076 adds accepted target std.mmio.Region, supplied only as a private executable-root @host loan backed by a trusted exact external mapping. It is non-Copy, non-Clone, neither Send nor Sync, exposes only readonly size, and has no public constructor, pointer/address projection, duplicate, close, unmap, subregion, split, typed-register, RMW, bulk, or async surface.
• Its exact eight fixed-width integer loads and eight stores first check the direction/width grant, complete byte bounds, and natural alignment. Failure reports AccessError after zero device accesses; success performs exactly one same-width RFC 0075 volatile access. zynx-launch v5 adds only the canonical mmio mapping grant kind and mandatory allow-only load/store byte-width arrays while copying v4 Directory and Network unchanged. All generic Wasm/WASI targets reject the type and grant. Implementation is pending.

Accepted owning-text growth migration:

• RFC 0051 makes append(^self, suffix), reserve(^self, total), and clear(^self) the sole owner-growth family. Named receivers use an explicit take such as (<-text).append(suffix). Append and reserve reuse sufficient capacity, otherwise grow at most once, and a checked failure drops the taken owner; clear is infallible and retains allocation and capacity.
• Only ^str exposes readonly logical capacity; str and &str projections forget it. Pure empty clone, repeat, and join results normalize to the allocation-free canonical owner. Empty tests use size == 0; is_empty is removed without an alias. There is no exact-reserve, shrink, builder, concatenation operator, owner-suffix overload, or new text-mutation family.

Accepted cursor-only iteration migration:

• RFC 0037 removes Iterable<T, Iter> and the std.iter.iterable module from the target. Concrete sources expose structural role-selected iter(self), iter(&self), or iter(^self); generic algorithms accept an explicit cursor. A direct accepted cursor-shaped next wins over iter. Stateful std cursors and adapters are affine, non-Copy, non-Clone, and next-only. A named direct cursor is exclusively borrowed by for and may resume after break; fresh or explicitly moved cursors are loop-owned. Normal null exhaustion is sticky and every later pull is effect-free. Iterator<T> and ExclusiveIterator<T> remain the two infallible generic cursor interfaces; fallible and mixed-view cursors remain structural. RFC 0038 removes every standard free and method collect. RFC 0039 retains exactly iter.count<T, I: Iterator<T>>(cursor: ^I) -> usize: it consumes an explicit owning cursor, pulls and ordinary-drops every item through exactly one terminal null, and cannot replace next/drop effects with a size-hint shortcut. Named cursors require <-cursor> and become moved; slices use .length, while fallible and lending cursors use explicit loops. There are no count methods or slice/source overloads. RFC 0040 retains exactly free take and skip over an explicit owning cursor. They return affine, non-Copy, non-Clone, next-only TakeCursor and SkipCursor values in the source region. Construction performs zero pulls; each adapter has sticky local exhaustion, and skipped owners are ordinary-dropped before the next pull. There are no methods, slice/source overloads, remainder recovery, size hints, or fallible/lending variants. Nesting order is semantic and nested counters cannot be fused through overflowing addition. RFC 0041 retains exactly free map and filter over an explicit owning cursor and concrete structural callback. MapCursor consumes each item into F: (&self, ^T) -> ^U; FilterCursor lends each item to P: (&self, T) -> bool, yields the exact accepted owner, and drops every rejected owner before the next pull. Both store the monomorphized callback inline without implicit erasure or allocation, keep local sticky exhaustion, and destroy the callback environment before their inner cursor. They add no methods, slice/source overloads, recovery, fallible/lending variants, or filter_map. RFC 0042 removes checked-in zip and ZipIter without a replacement. A destructive next-only pair cannot discover which side ends first symmetrically: one side must yield an owner before the other is known to be exhausted. Pairing therefore uses an explicit loop that exposes probe order and the unpaired-owner policy. No ZipCursor, method, source overload, alias, recovery, peek/lookahead, or exact-size abstraction is added. RFC 0043 replaces checked-in EnumerateIter, its cursor-copy iter, Iter.enumerate, and slice/source overloads with exactly one consuming free enumerate over ^I in Source. It returns an affine, non-Copy, non-Clone, next-only EnumerateCursor<T, I> in the same region. Construction performs no pull or allocation; the counter starts at zero and advances with ordinary checked usize addition after a successful pull and before yielding the exact owner. Overflow traps without unwind or recovery, local exhaustion is sticky, breaking a loop preserves cursor and counter state, and drop does not drain. There is no method, source adaptation, custom start, generic counter, arithmetic variant, size hint, reset, or recovery accessor. Other adapter redesign remains deferred. RFC 0044 replaces checked-in borrowed-slice fold/reduce and Iter.fold with exactly two free consuming cursor terminals. They transfer exact accumulator/item owners through an exclusively borrowed concrete callback in strict-left order and perform one terminal pull. fold uses an explicit initial owner; reduce seeds from the first owner and returns null for empty input. There is no callback erasure, method/source overload, reassociation, recovery, or fallible/lending/right/ parallel variant. Iterator sum/min/max are removed so arithmetic, ordering, tie, and losing-owner policy remains explicit callback code. RFC 0045 replaces checked-in Iter.any/all/find with exactly three free functions borrowing &I and concrete &P. A decisive result leaves the exact caller-owned cursor immediately after that owner; boolean terminals destroy it and find returns it exactly. Exhaustion performs one terminal pull. All seven methods disappear, and position, nth, last, and next_or have no compatibility aliases. There is no consuming/source overload, remainder wrapper, callback erasure, or fallible/lending/async family. RFC 0046 retains exactly explicit safe Bytes(str) and Bytes([u8]), readonly length, bounded at/slice, and readonly ptr. It removes public raw/empty construction, implicit adaptation, View, identity/emptiness helpers, raw-byte string mutation, and TakenByte. RFC 0053 makes every remaining raw view name a real owner/source anchor through mem.view; Bytes itself still has no raw constructor. RFC 0048 makes plain [...] exclusively an inline, nonallocating fixed-array literal and ^[...] the sole dynamic owning-slice literal. Only exact ^[] is infallible; every nonempty list and every repeat/range/expansion owning form exposes AllocError through required try/catch. of_one and of_two are removed. The inventory table still lists checked-in Iterable, cursor-copy iter methods, source overloads, collect, and old counting/bounded/map/filter/zip/ aggregation/search surfaces as transitional source until implementation.

Accepted owning-slice growth migration:

• RFC 0052 gives only ^[T] the consuming push, reserve, clear, insert, pop, and remove methods; [T] and &[T] remain two-word views without capacity or editing. Named takes use (<-xs). push and insert take ^T; pop returns ^(^[T], ^T?) and remove returns ^(^[T], ^T), with no target Taken type. Shared conditional clone remains. Growth reuses sufficient capacity under a private amortized strategy, clear reverse-drops while retaining storage, checked failure drops taken arguments, zero-sized growth has logical rather than physical capacity, and invalid dynamic positions trap. Slice append is removed. The table below still records the checked-in internal source symbols as transitional until implementation.
• RFC 0054 adds a separate output(^self, additional) transition to ^OutputSpan<T>. It does not make [T] or &[T] growable and does not expose random initialization or a generic raw output pointer.

Accepted keyed-collection migration:

• RFC 0026 replaces caller-supplied final-hash/equality constructors with one canonical HashKey: Hashable identity and a private lazy per-collection keyed finalizer. First insertion reports unavailable entropy without a weak fallback, and iteration order is seed-dependent and unspecified. RFC 0027 replaces separate map/set engines with one package-private flat SwissTable RawTable<E>. RFC 0028 makes mutation ownership explicit: replacement and duplicate insertion return every displaced incoming/stored owner, while removal returns the exact stored owner or key/value pair. RFC 0029 replaces value-only/bool lookup with shared HashMapEntry, affine HashMapExclusiveEntry, and stored-representative Set.get; receiver access explicitly selects map.get or (&map).get, and contains/get_mut aliases do not exist. RFC 0030 defines readonly exact length and a tombstone-aware logical capacity lower bound, total-length reserve(total), and retaining clear; physical slot counts, shrinking, manual compaction, and aliases are not public. RFC 0031 replaces the physical entries/keys/values cursor family with exactly five role-selected cursors under iter: shared, projection-exclusive, and consuming map cursors plus shared and consuming set cursors. RFC 0032 makes HashMap<K, V>() and Set<T>() the sole empty constructors, fixes both core types to the built-in process-allocation domain, and leaves reserve(total) as the sole seed-neutral preallocation operation. Core collections have no allocator parameter, stored or erased allocator capability, allocator accessor, or ambient allocator selection; their Send/Sync capabilities are structural only in their elements. RFC 0033 adds conditional structural Clone: each Copy component is copied and each non-Copy component must implement Clone; the independent result preserves the exact table state and private seed without entropy, hashing, equality, or a fresh-seed variant. All collection cursors remain non-Clone. RFC 0034 adds only shared extensional Set.equal, implemented as left-set scan plus right-set lookup under the element's canonical HashKey identity. It adds no collection operators, map equality, callback comparison, collection Hashable/HashKey conformance, or Eq interface. RFC 0035 adds only owner-preserving HashMap.merge and Set.merge: non-conflicting exact owners transfer, destination conflicts win and remain in the source, and checked failure rolls both collections back completely. It adds no bulk count or cursor, iterator construction/collection/extension API, or bulk callback. RFC 0036 adds only destructive Set.intersect: it retains exact left representatives present under canonical HashKey identity, drops the left complement in the same publicly unspecified order as clear, retains left allocation and seed, and leaves the shared right set unchanged. It adds no returning algebra, predicate family, callback retention API, operators, or aliases. The table below remains a source inventory, so it retains the current callback-based collection, partial-owner mutation results, old lookup and physical cursor types, physical bucket-count capacity, and Hashable/Hasher exports until implementation.

Complete Module Inventory

Module	Stability	Public Types	Public Functions, Values, And Re-exports	Public Errors	Notes
std	mvp	Range, ClosedRange	copy, move, drop, clone	none	Auto-preluded root helper namespace. This does not auto-import std submodules. move and drop are compiler-recognized ownership operations; no forget or leak counterpart exists. copy duplicates an implicitly-copyable value; clone deep-copies a Cloneable value (the Cloneable interface itself lives in std.cloneable) through a shared borrow. Range (a..<b) and ClosedRange (a...b) are the value types produced by the range operators and used for range iteration and slicing.
std.async.fs	accepted target	File, AppendFile	open_file, open_append, create_directory, remove, rename, sync_directory	IOError	RFC 0063 cooperative-safe filesystem file owner, RFC 0070 namespace mutations, RFC 0072 explicit durability barriers, and RFC 0073 atomic append owner. It shares std.fs path, Dir, RemoveKind, metadata, FileAccess/OpenDisposition/OpenMode, and AppendAccess/AppendMode, but its owners are nominally distinct from blocking fs owners. Cold open_file preserves RFC 0071 semantics; cold open_append produces only an append-capable owner. AppendFile.write performs one possibly short atomic EOF append without an offset or hidden retry; optional read_at observes the same identity, and sync remains independent. Every operation is an ordinary cold Future producer using native completion or a bounded fallback, while cancellation retains buffers, capabilities, paths and handles until true completion. RFC 0074 adds no synchronous or asynchronous publication owner/helper: the explicit short operations and barriers remain the only portable composition. No conversion, hidden cursor, direct stream interface, whole-file/publication helper or async traversal exists. Checked-in implementation pending.
std.async.io	accepted target	Reader, Writer, Stream	write, read	IOError	Generic async byte capabilities. RFC 0065 removes integer descriptor wrappers and async standard-handle constructors; resource implementations retain nominal owners and private generation-bound readiness. A future async standard-stream surface requires a separate resource-specific contract.
std.allocator	mvp	Allocator	none	AllocError	Transitional checked-in source only. RFC 0058 deletes this complete module, type, constructors, methods, callbacks, provider identity, and error origin without an alias or re-export.
std.arena	mvp	Arena	none	Error	Generational arena that mints copyable, non-owning Handle<T> ids. Removing an entry bumps the slot generation so stale handles are rejected (Error.Stale/Error.Missing). RFC 0064 classifies add as one non-positional entry insertion and remove as handle-selected exact-owner removal; no mutation aliases are added. See arena.
std.arith	mvp	none	none	none	Documentation home for builtin numeric type-call parsing. Import each dotted policy module directly. See arith.
std.arith.parse	mvp	none	parse_i8, parse_i16, parse_i32, parse_i64, parse_i128, parse_isize, parse_u8, parse_u16, parse_u32, parse_u64, parse_u128, parse_usize, parse_float	ParseError	Base-10 string-to-number optional parsers returning T? (null on overflow or invalid input), plus ParseError.Invalid used by builtin numeric type calls. Per-type, with no generic parse_int<T>. See arith.
std.arith.checked	mvp	none	add, sub, mul	none	Checked integer helpers return nullable results instead of trapping.
std.arith.overflowing	mvp	none	add, sub, mul	none	Helpers return result plus overflow flag.
std.arith.saturating	mvp	none	add, sub, mul, shl	none	Helpers clamp at numeric bounds.
std.arith.wrapping	mvp	none	add, sub, mul	none	Helpers perform explicit wrapping arithmetic.
std.atomic	mvp	MemoryOrder, Atomic	new	none	Lock-free atomic cells for compiler-approved primitive and compact representable types. Operations use explicit memory ordering; unsupported representations should use std.mutex.
std.bit	mvp	none	swap_bytes, reverse_bits, count_ones, leading_zeros, trailing_zeros, rotate_left, rotate_right	none	Scalar integer bit operations. swap_bytes is a const fn over closed ByteAlignedInteger; it includes 8-bit identity and byte-aligned custom widths, with no Vector/Matrix overload.
std.builtin	internal	Copy, Scalar, Integer, ByteAlignedInteger, Signed, Unsigned, Float, AtomicRepresentable	none	DynamicError	Auto-imported compiler surface. Copy is the sole protected duplication marker; Copyable and ImplicitCopy are free user identifiers. Scalar covers primitive integers, floats, and bool; closed ByteAlignedInteger refines scalar Integer by semantic width; AtomicRepresentable gates lock-free atomic storage. There is no exported ManuallyDrop, @forget, forget/leak helper, or source-visible drop-flag operation. Vector/Matrix construction, ThreadLocal<T>, Matrix @hadamard, mask @all/@any, and eager @select are compiler-owned expressions rather than std functions.
std.bytes	mvp	Bytes, View	none	none	Current transitional exports include the dead View interface plus public raw/empty construction and helper methods. RFC 0046 target exports only region-typed Bytes: Copy, constructed safely and explicitly as Bytes(str) or Bytes([u8]), with readonly length, bounded at/slice, and readonly ptr. It has no implicit adaptation, public raw/empty constructor, View, identity bytes, or is_empty; RFC 0053 requires initialized foreign storage to cross through owner-anchored mem.view before safe Bytes(view) construction.
std.bytes.core	mvp	Bytes, View	none	none	Current transitional implementation of Bytes and View. RFC 0046 removes View and the public raw/empty/helper surface; the target core has only the explicit checked-source Bytes boundary, while concrete owner-specific methods may still return Bytes.
std.channel	mvp	Recv, Sender, Receiver	bounded	ChannelError	Bounded channels own logical messages. Channel<void> carries ordinary zero-byte events, counts capacity in events, and keeps value distinct from close. Cross-thread-capable sends require send-safe payloads. Unqualified Futures are rejected; a region-free ^Future<T> where Send is a valid cold-frame payload without implying T: Send.
std.cloneable	mvp	Cloneable	none	none	The Cloneable<R> deep-duplication capability interface (fn clone(self) throws(AllocError) -> R). A lightweight module so heap-owning types (owning ^str) and std.slice.clone can depend on it without pulling the std root prelude.
std.collections	mvp	HashMap, Set	none	none	Collection facade. Growing, structurally cloning, or owner-preserving merging owned collections may throw AllocError; first destination seeding may also throw random.RandomError. The accepted storage target shares one private flat SwissTable RawTable<E>. RFCs 0028–0030 define ownership, lookup, length, capacity, reserve, and clear. RFC 0031 adds exactly HashMapIter, HashMapExclusiveIter, HashMapOwnedIter, SetIter, and SetOwnedIter, selected only by receiver role under iter. RFC 0032 fixes the sole empty constructors as HashMap<K, V>()/Set<T>(), uses only built-in allocation, and makes element types the exact structural Send/Sync conditions. RFC 0033 adds conditional Clone using Copy or non-Copy Clone components and preserves exact table/seed state; cursors remain non-Clone. RFC 0034 adds only shared extensional Set.equal; collections have no equality operators, map equality, equality callback, Hashable/HashKey conformance, or Eq interface. RFC 0035 adds transactional owner-preserving merge to both collections: conflicts remain in the exclusive source and destination wins. RFC 0036 adds only allocation-free, in-place Set.intersect, retaining exact left representatives and leaving the shared right set unchanged. RFC 0064 fixes put, add, merge, remove, and clear as the exact associative-container mutation vocabulary and rejects bulk and removal aliases. There is no bulk count/cursor, iterator bulk-ingestion surface, returning set algebra, predicate family, callback retention API, operator, or alias. RawTable, allocator policy, physical slots/tombstones, target group width, and raw cursors are not public API.
std.collections.hash_map	mvp	HashMapEntry, HashMapEntryIter, HashMapKeyIter, HashMapValueIter, HashMap	none	none	Current transitional hash-map source: its callback/custom-allocator constructors, physical owning HashMapEntry, value-only lookup, bucket-count capacity, 3/4 load, allocating fresh reserve(0), absent conditional structural clone, absent owner-preserving merge, and entries/keys/values cursor family are not accepted contracts. The target has only HashMap<K, V>(); reserve(total) is the only preallocation operation. Target clone preserves a distinct exact table/seed copy and reports only AllocError. RFC 0035 target merge(&self, source: &Self) transactionally transfers exact non-conflicting key/value owners and leaves conflicts in the exclusive source; destination entries always win. RFC 0031 target shared map.iter yields HashMapEntry, exclusive (&map).iter yields affine HashMapExclusiveEntry steps, and consuming (<-map).iter yields owned HashMapItem; cursors scan each authoritative Full slot once and ignore tombstones/mirror. No collection equal, equal_by, ==, !=, generic bulk ingestion, bulk count/cursor, set algebra, iter_mut, into_iter, projection aliases, owned-cursor remainder, stable order, fresh-seed clone, or raw cursor exists.
std.collections.set	mvp	SetEntry, SetEntryIter, SetIter, Set	none	none	Current transitional hash-set source: its callback/custom-allocator constructors, bool lookup, physical SetEntry/SetEntryIter, bucket-count capacity, 3/4 load, allocating fresh reserve(0), absent conditional structural clone, absent extensional equal, absent owner-preserving merge, absent in-place intersect, and entries/keys/values aliases are not accepted contracts. The target has only Set<T>(); reserve(total) is the only preallocation operation. Target clone preserves a distinct exact table/seed copy and reports only AllocError. RFC 0034 target equal compares length, then scans the left set and looks up each value in the right set under canonical HashKey identity, without allocation, entropy, mutation, callback, or error. RFC 0035 target merge(&self, source: &Self) transactionally transfers exact non-conflicting representatives and leaves conflicts in the exclusive source; destination representatives always win. RFC 0036 target intersect(&self, other: Self) scans the left set, preserves exact left representatives found in the shared right set, and explicitly drops the complement in publicly unspecified order. It allocates and deallocates nothing, retains left allocation and seed, leaves other exact, and cannot throw. RFC 0031 target shared set.iter yields the exact stored representative and consuming (<-set).iter yields its owner. Set has no exclusive cursor because every value is a key. No equal_by, equality operators, generic bulk ingestion, bulk count/cursor, returning intersection/union/difference/symmetric_difference, subset/superset/disjoint predicates, retain callback, set operators, alternate in-place intersection alias, into_iter, owned-cursor remainder, stable order, fresh-seed clone, or raw cursor exists.
std.compress	mvp	none	deflate, gzip	none	Compression facade. Public algorithms return io.MemoryStream for allocating helpers.
std.compress.deflate	mvp	Options, Format	no_compression, best_speed, best_compression, default_compression, compress_bound, compress_into, decompress_into, compress, decompress	CompressError	Deflate and zlib helpers. Allocating helpers may also throw AllocError and io.IOError.
std.compress.gzip	mvp	Options	no_compression, best_speed, best_compression, default_compression, compress_bound, compress_into, decompress_into, compress, decompress	CompressError	Gzip helpers. Allocating helpers may also throw AllocError and io.IOError.
std.compress.internal.zlib_ffi	internal	ZStream	z_no_flush, z_finish, z_ok, z_stream_end, z_need_dict, z_stream_error, z_data_error, z_mem_error, z_buf_error, z_version_error, max_chunk, compress_bound, deflate_init, inflate_init, deflate_step, inflate_step, deflate_end, inflate_end, raise	CompressError	Internal zlib FFI shim shared by deflate and gzip.
std.cpu	mvp	Feature	has	none	Typed, allocation-free runtime CPU feature detection. Feature is a closed arch-prefixed Zynx registry and has(feature) is process-lifetime stable; wrong-architecture features report false. Pairs with typed @target_feature for explicit runtime dispatch. See cpu.
std.crypto	mvp	none	secure_zero, box, cipher, digest, errors, mac, password, random, sign	CryptoError	Crypto facade. Key-owning types zero secret storage on drop where implemented.
std.crypto.box	mvp	PublicKey, SecretKey, Seed, Nonce, KeyPair	public_key_bytes, secret_key_bytes, seed_bytes, nonce_bytes, tag_bytes, encrypt_overhead, encrypt_into, decrypt_into, encrypt, decrypt	CryptoError	Public-key authenticated encryption. Allocating helpers may also throw AllocError.
std.crypto.cipher	mvp	Key, Nonce	key_bytes, nonce_bytes, tag_bytes, encrypt_overhead, encrypt_into, decrypt_into, encrypt, decrypt	CryptoError	Shared-key authenticated encryption. Allocating helpers may also throw AllocError.
std.crypto.digest	mvp	DigestAlgorithm, Digest	blake2b_bytes_min, blake2b_bytes_max, blake2b_bytes, sha256_bytes, sha512_bytes, bytes, sum_into, sum, blake2b_into, sha256_into, sha512_into, blake2b, sha256, sha512	CryptoError	BLAKE2b, SHA-256, and SHA-512 one-shot digests. Allocating helpers may also throw AllocError.
std.crypto.errors	mvp	none	none	CryptoError	Shared crypto error set.
std.crypto.internal.hash	internal	none	blake2b_into, sha256_into, sha512_into, auth256_into, auth512_into	CryptoError	Internal hash runtime shim shared by digest and MAC modules. Not a public user API.
std.crypto.internal.util	internal	none	status_ok, status_invalid, status_buffer, status_auth, status_random, status_resource, status_init, raise, secure_zero, equal, alloc_bytes, copy, copy_exact	none	Internal crypto status and buffer helpers. Not a public user API.
std.crypto.mac	mvp	MacAlgorithm, Key, Tag	blake2b_key_bytes_min, blake2b_key_bytes_max, blake2b_key_bytes, blake2b_tag_bytes_min, blake2b_tag_bytes_max, blake2b_tag_bytes, hmac_sha256_key_bytes, hmac_sha256_tag_bytes, hmac_sha512_key_bytes, hmac_sha512_tag_bytes, key_bytes, tag_bytes, sign_into, sign, verify	CryptoError	Keyed BLAKE2b, HMAC-SHA256, and HMAC-SHA512 tags. Allocating helpers may also throw AllocError.
std.crypto.password	mvp	none	argon2id	none	Password-hashing facade.
std.crypto.password.argon2id	mvp	Profile, Salt	salt_bytes, str_bytes, bytes_min, bytes_max, opslimit_interactive, memlimit_interactive, opslimit_moderate, memlimit_moderate, opslimit_sensitive, memlimit_sensitive, hash_password, verify, needs_rehash, derive_key_into	CryptoError	Argon2id password hashing and key derivation. Allocating helpers may also throw AllocError.
std.crypto.random	mvp	none	fill, uint32, uniform	CryptoError	Cryptographic randomness.
std.crypto.sign	mvp	SignAlgorithm, PublicKey, SecretKey, Seed, Signature, KeyPair	public_key_bytes, secret_key_bytes, seed_bytes, signature_bytes, sign_into, sign, verify	CryptoError	Ed25519 signatures. Allocating helpers may also throw AllocError.
std.encoding	mvp	none	base64, hex	HexError	Text encoders and decoders over explicit byte views.
std.encoding.base64	mvp	Alphabet, Padding	encode, decode	Base64Error	Standard and URL-safe Base64 encoding returns UTF-8 owning ^str output and decoding returns owned bytes.
std.encoding.hex	mvp	Case	valid, encode, encode_into, decode_into, decode	HexError	Hex encode/decode helpers. Allocating helpers may also throw AllocError.
std.env	mvp	Var	args, chdir, cwd, get, items, remove, set	EnvError	Current transitional source surface. RFC 0021 replaces the false owning argv experiment with opaque immutable lossless Args/Arg handles; RFC 0022 deletes live-CWD functions; RFC 0024 deletes live get/set/remove and allocating items in favor of immutable lossless Variables/Variable/Name/Value process-start views and EnvironmentError.
std.ffi	accepted target	CStr	CStr, CStr.find	CStrError	RFC 0059 target as amended by RFC 0061. CStr in L is a bounded immutable terminated byte view and ^CStr its exact built-in-domain owner. c"..." creates static values; dynamic text uses checked allocating construction and foreign input requires an anchored bound. There is no ^str projection, CString, unbounded pointer scan/adoption, mutable C string, implicit C ABI lowering, or Wasm-string conversion.
std.fs	mvp	FileInfo, FileKind, AtomicDurability, WatchEventKind, WatchEvent, PollResult, Watcher	append, canonicalize, copy, cwd, exists, glob, list, matches, mkdir, mkdirs, move, read, read_bytes, readlink, remove, rmdir, rmtree, stat, symlink, tmpdir, tmpfile, walk, watch, write, write_atomic	none	Current transitional filesystem facade. RFC 0022 deletes cwd; RFC 0023 replaces unanchored relative str operations with lossless path roles and Dir-anchored operations. RFC 0066 injects initial Dir authority only through private executable-root @host let name: fs.Dir in _; loans and removes open_root, MissingRoot, and the named-root registry. RFC 0068 supplies backing only through an explicit per-instance zynx-launch plan; a path or process_start source may satisfy any exact binding name, and start is not magic. RFC 0069 adds the mandatory closed directory-right set for duplicate, nested open, entries, walk, metadata and exact file open/read-at/write-at/create/truncate effects; there is no broad or future-widening preset. RFC 0070 adds public target RemoveKind and the only target namespace mutations: one-final-entry Dir.create_directory, explicit-kind Dir.remove, replace-capable dual-Dir rename and cold Future counterparts. zynx-launch v2 adds exactly five corresponding directory rights while preserving v1 and Network unchanged; cross-filesystem rename is exact IOError.CrossDevice. RFC 0071 defines target FileAccess { Read, Write, ReadWrite }, five-case OpenDisposition, and explicit OpenMode { access, disposition }. All combinations are valid; their complete right sum is checked before lookup, CreateNew is atomic and non-following at the final entry, and sync/async opens share the contract. No new launch right/version, .Read shorthand, option builder, Boolean flags, bitmask, default or append case in OpenMode is added. RFC 0025 replaces list/walk traversal with concrete fallible lending Dir.entries()/Dir.walk() cursors and deletes free walk/glob policy. RFC 0063 target makes this namespace blocking, adds affine offset-only fs.File, and moves cooperative-safe access to distinct std.async.fs.File. Target file operations are one possibly-short read_at/write_at; RFC 0072 adds explicit full-integrity File.sync and namespace Dir.sync, plus their cold Future forms. zynx-launch v3 adds independent open_file.sync and sync_directory rights while freezing v1/v2 and Network. RFC 0073 adds target AppendAccess { Append, ReadAppend }, AppendMode, and distinct blocking/asynchronous AppendFile owners. Their write performs one possibly short atomic EOF placement with no offset or hidden write_all; ReadAppend permits same-identity read_at, and sync uses the independent existing sync right. Launch v4 adds only open_file.append; uncertified targets fail closed with IOError.Unsupported = 18, never size-plus-write_at emulation. RFC 0074 accepts no publication owner/helper, generated staging-name policy, cleanup-on-drop, rollback, recovery transaction, launch right, or v5 schema. Its only portable same-parent recipe composes caller-chosen CreateNew, an explicit short-write loop, File.sync, drop, path-based rename, and Dir.sync on the exact directory containing both direct-child names; coordination and phase recovery remain application policy. There is no hidden cursor, direct stream interface, ambient/whole-file/publication helper, durability mode, exists, read_text, cross-filesystem move fallback, or async traversal. The listed free helpers—including ambient whole-write append and write_atomic—remain checked-in migration source only.
std.fs.internal.dir	internal	none	mkdir, mkdirs, rmdir, rmtree, list, cwd, tmpdir	none	Internal directory operations used by the current filesystem facade. Its cwd shim is transitional under RFC 0022.
std.fs.internal.errors	internal	none	errno_kind, raise_kind, c_path, own_text	none	Internal filesystem error and C path/text helpers shared by filesystem submodules.
std.fs.internal.file	internal	FileKind, AtomicDurability, FileInfo	user_read, user_write, user_execute, group_read, group_write, group_execute, other_read, other_write, other_execute, setuid, setgid, sticky, info_from_raw, read_bytes, read, write, append, copy, move, write_atomic, tmpfile_in, symlink, readlink, remove, exists, canonicalize, stat, lstat	none	Internal file operations and metadata behind std.fs. Its append and atomic-write helpers are transitional checked-in implementation, not target APIs under RFC 0073/0074.
std.fs.internal.walk	internal	none	walk, glob, matches	none	Transitional internal recursive walk and segment-scoped glob matcher behind the current facade. RFC 0025 removes this policy surface in favor of capability-anchored Dir cursors.
std.fs.internal.watch	internal	WatchEntry, WatchEventKind, WatchEvent, PollResult, Watcher	watch	none	Internal filesystem watcher implementation behind std.fs.
std.fs.path	mvp	none	basename, dirname, extension, is_absolute, join, normalize	none	Lexical path helpers. No filesystem access; normalize is lexical and does not resolve symlinks. is_absolute recognises both POSIX and Windows roots.
std.async	accepted target	Future, Join, Scope	ready, sleep, yield, blocking, all, race, timeout	TimeoutError	Compiler-recognized cold-future surface. Future<void> is ordinary typed completion, and all preserves every child position including void (zero children normalize to void). Plain Future is non-Send/non-Sync; sole Future<T> where Send proves the complete frame portable. Local start/await accept either, while parallel start additionally requires Send success and error payloads. Scope close cancel-and-joins children; cancellation is lifecycle state. RFC 0063 adds the one general blocking bridge for a concrete consuming where Send closure on the bounded pool; after start, cancellation waits for closure completion and never detaches work. RFC 0064 keeps the execution verb Scope.start; removed Group.add receives no alias. RFC 0065 removes public integer readable/writable; nominal resources own private generation-bound readiness.
std.hash	mvp	Hashable, Hasher	crc32, crc32c, fnv32a, fnv64a	none	Hash interfaces and algorithm facade. These interfaces are intended for generic constraints in the current API.
std.hash.core	internal	Hashable, Hasher	none	none	Shared hash interfaces used by the hash facade and algorithm modules.
std.hash.crc32	mvp	Crc32	sum	none	CRC-32 hasher and one-shot helper.
std.hash.crc32c	mvp	Crc32c	sum	none	CRC-32C hasher and one-shot helper.
std.hash.fnv32a	mvp	Fnv32a	none	none	FNV-1a 32-bit hasher.
std.hash.fnv64a	mvp	Fnv64a	none	none	FNV-1a 64-bit hasher.
std.internal.num_parse	internal	none	parse_integer, parse_i8, parse_i16, parse_i32, parse_i64, parse_i128, parse_isize, parse_u8, parse_u16, parse_u32, parse_u64, parse_u128, parse_usize, parse_f32, parse_f64	none	Internal compiler target for builtin numeric type calls. User code should use builtin numeric type-call syntax instead of importing this module.
std.internal.slice	internal	Taken	clone, append, push, pop, insert, remove	none	Current transitional backing for built-in slice methods; user code cannot import it. RFC 0052 target has exactly owner-only consuming push/reserve/clear/insert/pop/remove plus shared clone, removes slice append, and returns owning tuples from pop/remove instead of any public or internal target Taken. RFC 0054 additionally introduces the public affine OutputSpan<T> transition for one bounded initialized suffix, with explicit commit/cancel and no set_len. RFC 0064 confirms that old append has no alias and rejects extend/removal synonyms. Only ^[T] exposes logical capacity. Growth reuses storage under a private amortized strategy; checked failure drops taken arguments, clear reverse-drops while retaining capacity, zero-sized growth needs no physical allocation, and invalid insert/remove/output bounds are defined traps. The checked-in Taken, always-copying append, non-explicit receiver examples, absent reserve/clear/output, capacity-as-role convention, avoidable reallocation, ZST allocation behavior, and unchecked dynamic pointer arithmetic are not target contracts. Transitional raw ordering helpers also disappear under RFC 0047.
std.internal.str	internal	none	is_empty, clone, append, push, pop, insert, remove, split, lines, repeat, TakenByte	none	Current transitional backing for built-in str methods. RFC 0061 removes all terminator/no-NUL assumptions, the scalar length property, and special one-scalar-string iteration; target iter returns affine RuneCursor, slice_bytes checks scalar boundaries, and append accepts str or rune. RFC 0050 supplies borrowed split/line cursors, RFC 0051 consuming growth, and RFC 0046 deletes raw byte mutation plus TakenByte. RFC 0064 fixes append as the complete text-suffix verb and gives the removed raw-byte mutators no aliases. User code cannot import this module.
std.internal.text	internal	none	owned_str, require_add, require_mul, c_path, own_text, append	none	Current transitional shared ^str builders for stdlib code. The duplicate always-allocating internal append, physical-capacity convention, and allocating empty builders are not RFC 0051 target contracts; target construction uses checked logical capacity, canonical empty output, and the same consuming growth primitive as public owner append. Imported only within std.
std.io	accepted target	Reader, Writer, Stream, Stdin, Stdout, Stderr, BufReader, BufWriter, MemoryStream	print, println, eprint, eprintln, write, read, stdin, stdout, stderr	IOError	Nominal synchronous byte I/O. RFC 0054 removes ByteBuffer and uses owning ^[u8] plus OutputSpan<u8>; RFC 0062 fixes measurement names and RFC 0064 the mutation vocabulary. RFC 0065 removes all Descriptor types and raw identities. RFC 0070 adds exact IOError.CrossDevice = 17 for nonportable filesystem/volume rename boundaries; RFC 0072 adds IOError.Unsupported = 18 for an exact durability barrier found unavailable only on a concrete resource. Process standard handles are opaque process-lifetime resources with no constructor, descriptor, or close. BufWriter.finish flushes before returning the wrapped writer; into_inner does not. CLI print helpers ignore low-level write status. Platform error mapping stays private.
std.iter	mvp	Iterator, Iterable, SliceIter, EnumerateIter, Iter, MapIter, FilterIter, TakeIter, SkipIter, ZipIter	enumerate, map, filter, take, skip, zip, fold, reduce, sum, min, max, count, collect	none	Current transitional source inventory, including checked-in free and method collect symbols removed from the accepted target by RFC 0038, method/slice counting surfaces removed by RFC 0039, old bounded-adapter surfaces replaced by RFC 0040, old erased-callback map/filter surfaces replaced by RFC 0041, left-first zip/ZipIter removed without replacement by RFC 0042, old copied/source-adapting enumeration replaced by RFC 0043, and old Copy-only aggregation replaced or removed by RFC 0044. The target has no collect, from_iter, to_slice, target-inferred materialization, or recovery wrapper: callers name the cursor and grow var out: ^[T] = ^[] through explicit fallible out = try (<-out).push(<-item); a borrowed Copy slice uses its existing clone(). RFC 0037 retains Iterator<T> and ExclusiveIterator<T> only as generic cursor interfaces, removes Iterable, makes stateful std cursors affine next-only values, gives direct cursor-shaped next precedence over structural role-selected source iter, exclusively borrows a named direct cursor so it can resume after break, and requires sticky effect-free null exhaustion. Generic algorithms accept explicit cursors; fallible and mixed-view cursors remain structural. RFC 0039 target exports exactly count<T, I: Iterator<T>>(cursor: ^I) -> usize; it consumes the cursor, ordinary-drops each yielded owner, performs exactly one terminal pull, and cannot bypass next/drop effects through a size hint. A named cursor is passed as <-cursor>, slices use .length, and fallible or lending cursors use explicit loops so checked failure and step-loan boundaries remain visible. RFC 0040 target exports exactly consuming free take/skip over ^I in Source, returning affine, non-Copy, non-Clone, next-only TakeCursor/SkipCursor values in that region. Construction pulls nothing; terminal state is locally sticky, and skip ordinary-drops each skipped owner before its next pull. There are no methods, slice/source overloads, recovery accessors, size hints, or fallible/lending variants; wrapper order is semantic and overflow-unsafe counter fusion is forbidden. RFC 0041 target exports exactly consuming free map/filter over ^I in Source, returning affine, next-only MapCursor/FilterCursor values that store a concrete monomorphized &self callback inline. Map transfers each ^T owner to its mapper once; filter shared-borrows each owner, yields the exact owner on true, and destroys it before the next pull on false. Construction has no pull, callback, implicit erasure, or hidden allocation; local exhaustion is sticky and cleanup destroys callback before cursor. There are no map/filter methods, source/slice overloads, cursor copies, callback recovery, fallible/lending variants, or filter_map; callback effect order must survive fusion. RFC 0042 target has no zip or ZipIter: the current adapter probes left first, drops an unpaired left owner when right ends, and has no local terminal state, while the target requires an explicit loop to expose probe order and recovery. RFC 0042 adds no ZipCursor, method/source overload, alias, remainder recovery, peek/lookahead, or exact-size interface. RFC 0043 target exports exactly consuming free enumerate<T, I: Iterator<T>, region Source>(cursor: ^I in Source) -> ^EnumerateCursor<T, I> in Source. The affine next-only adapter starts at zero, performs one inner pull per item, advances with checked usize addition before yielding the same owner, and has locally sticky exhaustion. Construction performs no pull or allocation; breaking preserves cursor/counter state, and drop performs no drain. There is no method, slice/source overload, custom start, generic counter, arithmetic variant, size hint, reset, or recovery surface. RFC 0044 target exports exactly consuming cursor-only fold and strict-left reduce, both exclusively borrowing concrete callbacks and transferring exact accumulator/item owners. fold returns its explicit initial owner for empty input; reduce returns null. There is no method/source overload, callback erasure, reassociation, recovery, or fallible/lending/right/parallel variant. Iterator sum/min/max are removed so arithmetic, ordering, tie, and losing-owner policy remains explicit callback code. RFC 0045 replaces checked-in Iter.any/all/find with exactly three free functions borrowing &I and concrete &P. A decisive result leaves the exact caller-owned cursor immediately after that owner; boolean terminals destroy it and find returns it exactly. Exhaustion performs one terminal pull. All seven methods disappear, and position, nth, last, and next_or have no compatibility aliases. There is no consuming/source overload, remainder wrapper, callback erasure, or fallible/lending/async family. RFC 0046 retains exactly explicit safe Bytes(str) and Bytes([u8]), readonly length, bounded at/slice, and readonly ptr. It removes public raw/empty construction, implicit adaptation, View, identity/emptiness helpers, raw-byte string mutation, and TakenByte; every remaining internal raw view needs a real owner/source anchor at the private trusted boundary. RFC 0048 makes plain [...] exclusively an inline, nonallocating fixed-array literal and ^[...] the sole dynamic owning-slice literal. Only exact ^[] is infallible; every nonempty list and every repeat/range/expansion owning form exposes AllocError through required try/catch. of_one and of_two are removed. The inventory table still lists checked-in Iterable, cursor-copy iter methods, source overloads, collect, and old counting/bounded/map/filter/zip/aggregation/search surfaces as transitional source until implementation. See iter.
std.iter.iterable	mvp	Iterable	none	none	Transitional checked-in source constraint and re-export; RFC 0037 removes this complete module and interface from the target without an alias.
std.iter.iterator	mvp	Iterator	none	none	Defines the static Iterator constraint re-exported by std.iter.
std.json	mvp	Value, Token, Decoder, Encoder, ObjectScope, ArrayScope	decode, encode, null, boolean, string, number, array, object	JsonError	Strict JSON decode/encode, mutable DOM values, streaming tokens, and closure-scoped streaming output backed internally by yyjson. Numbers are exposed as validated source text. RFC 0062 renames fallible dynamic cardinality from Value.len() to Value.length(); it remains a method because non-container values report JsonError.Type. RFC 0064 classifies retained object put and array-tail push names but does not ratify the complete DOM mutation contract.
std.math	mvp	none	sqrt, abs, floor, ceil, trunc, round, rint, sin, cos, tan, exp, exp2, log, log2, log10, pow, copysign, min, max, fma, is_nan, is_finite, is_inf, PI, TAU, E, LN2, LN10, SQRT2, PI_F128, TAU_F128, E_F128, LN2_F128, LN10_F128, SQRT2_F128	none	Float math over LLVM intrinsics, generic over the Float bound (f16/f32/f64/f128) with per-lane Vector<T, N> overloads, plus checked integer abs/min/max. See math.
std.matrix	mvp	none	transpose, fill, identity, wrapping_mul	none	Helpers for the built-in Matrix<T, R, C> magic type: transpose for Float, Integer, and bool masks, fill, identity (Float and Integer overloads), and wrapping integer matrix multiplication. The * operator is checked for integer elements. Trusted implementations may use private target-independent semantic contracts; raw backend intrinsic names are not public API. See matrix.
std.mem	mvp	none	copy, move, set, zero, compare, find, slice, byte_at, write_at, read_at, drop_at, swap_bytes	none	Current transitional source inventory: MaybeUninit<T> and AllocError are not yet checked in here, while slice, write_at, read_at, and drop_at still are. RFC 0050 removes from_cstr without an alias because it reinterprets foreign storage as an owner; RFC 0059 places the bounded successor in std.ffi, not std.mem. RFC 0053 removes two-argument slice and adds only overloaded unsafe view(ptr, length, anchor), returning shared [T] in L from an ordinary anchor or exclusive &[T] in L from &anchor. It requires initialized provenance-correct storage and never creates an owner or initialization state. RFC 0054 keeps contiguous owner-tail initialization on OutputSpan<T> rather than adding another std.mem view. RFC 0055 adds only SDK-internal liveness-blind RawStorage<T> for sparse core containers. RFC 0056 adds target type MaybeUninit<T> for one staged slot with role-directed .ptr and unsafe initialize/take, and removes write_at/read_at/drop_at without aliases. RFC 0058 moves the sole AllocError.OutOfMemory identity here and adds no public raw allocation, reallocation, release, provider, or adoption surface. Explicit wrapper aggregates remain ordinary composition; there is no dedicated raw-range constructor, fresh-allocation mem.view retyping, range-wide publication/conversion, adoption, uninitialized-buffer API, ArrayBuilder, or generic raw output pointer.
std.mem.volatile	accepted target	none	load, store	none	RFC 0075 exact unsafe scalar access. Each name has only eight non-generic overloads for i8, u8, i16, u16, i32, u32, i64, and u64; store returns void(). Every reached call requires one target-certified native same-width volatile access and otherwise fails target compilation. The caller supplies provenance, liveness, alignment, and authority. No atomicity, synchronization, ordinary/atomic ordering, fence, cache/DMA, completion, endian, MMIO-capability, or device-protocol promise is implied. Public @zynx.volatile.read/write is removed; implementation is pending.
std.mmio	accepted target	Region	none	AccessError	RFC 0076 exact host-provided MMIO authority. Region is a non-Copy, non-Clone, non-Send, non-Sync host loan with readonly size and exactly eight fixed-width unsafe integer loads plus eight matching stores. Permission, complete byte bounds, and alignment failures perform zero accesses; success performs exactly one same-width RFC 0075 volatile operation. zynx-launch v5 supplies only exact named mappings with independent mandatory load/store width allowlists. There is no constructor, pointer/address projection, duplicate, close/unmap, subregion, typed register, RMW/bulk helper, async surface, generic Wasm/WASI support, or stronger memory/device protocol. Implementation pending.
std.mutex	mvp	Mutex, MutexGuard	new	none	Heap-backed mutex owning a value. Callback-scoped with, read, and try_with access keeps a protected reference from escaping the lock lifetime; lock/get provide an RAII guard that unlocks on drop.
std.net	accepted target	Network	dns, ipaddr, tcp, udp	NetError	Capability-scoped networking facade. Network-resource creation and DNS borrow an explicit Network; RFC 0066 injects it only through a private executable-root @host let name: net.Network in _; loan, and RFC 0068 supplies each backing policy only through an explicit exact per-instance grant plan rather than package metadata, argv/env or discovery. RFC 0069 fixes mandatory independent allow-only rules for raw-name resolution, TCP connect/listen and UDP bind/connect/send-to, with canonical numeric CIDR, tagged port selectors and explicit IPv6 scope. RFC 0067 retains one forward dns.resolve returning scope-preserving ResolvedAddr data. The generic socket namespace, raw identities, ambient acquisition, registries, defaults, string lookup, reverse/service DNS, numeric-host fallback and connect-by-name policy are removed.
std.ordering	mvp	Ordering	reverse, compare_i8, compare_i16, compare_i32, compare_i64, compare_i128, compare_isize, compare_u8, compare_u16, compare_u32, compare_u64, compare_u128, compare_usize, compare_total_f32, compare_total_f64, compare_str	none	Explicit three-way ordering vocabulary and primitive comparators. Float comparators use one deterministic IEEE-total-order key; no nominal ordering interface or implicit order exists. See ordering.
std.net.dns	accepted target	ResolvedAddr	resolve	none	One cold forward lookup borrowing explicit Network and host text, returning a nonempty owned address sequence that preserves resolver order, duplicates and IPv6 flow/scope metadata. Port attachment is explicit. Protocol, service/reverse lookup, numeric fallback and connection policy are removed.
std.net.errors	accepted target	none	none	NetError	Address and port validation plus InvalidName for input which is not a resolver name. Private host-error helpers map resolver and socket failures to io.IOError.
std.net.ipaddr	accepted target	AddressFamily, Ipv4Addr, Ipv6Addr, IpAddr, SocketAddr	none	none	Valid tagged address parse/format helpers. RFC 0065 removes SocketAddr.raw/from_raw; IPv6 addresses preserve scope and flow information in the typed value.
std.net.socket	removed target	none	none	none	RFC 0065 removes the complete public generic Socket/SocketKind layer. Private runtime helpers may remain during migration.
std.net.tcp	accepted target	TcpListener, TcpStream	none	none	Nominal listening and connected TCP resources. Construction borrows Network; streams implement async Reader/Writer and retain resource/buffer loans until true completion. No raw identity or zombie state exists.
std.net.udp	accepted target	UdpSocket, ConnectedUdpSocket, ReceivedDatagram	none	none	Separate unconnected and connected UDP owners. Receive consumes an OutputSpan<u8> and reports source plus explicit truncation; send is all-or-error.
std.os	removed target	none	none	none	RFC 0065 removes the complete POSIX-shaped module from portable safe std. Platform-specific raw resource interop is deferred to a separate RFC; private SDK/runtime operations remain implementation details.
std.process	accepted target	ExitStatus, EnvironmentVariable, EnvironmentVariables, Environment, Stdio, Options, WorkingDirectory, PipeReader, PipeWriter, Child, SpawnResult	exit, exit_success, exit_failure, spawn, run, success, code, signal	ProcessError	RFCs 0021–0024 define immutable arguments/environment/directory policy. RFC 0065 limits Stdio to Inherit, Ignore, and Pipe; removes fd_stdio and all raw pipe identities/zombie state; makes pipe fields nullable owners; and makes Child.wait(^self) consuming.
std.slice	mvp	BinarySearchResult, OutputSpan<T>	sort, binary_search	none	One typed explicit-comparator ordering path. Owning construction is language syntax ^[...], not a std.slice function; RFC 0048 removes of_one/of_two. sort is stable, retains the exact owner/storage and allocates no heap; binary_search returns .Found at the first equivalent element or .Insert at the lower-bound insertion point. RFC 0052 fixes growth and editing as owner-only consuming push/reserve/clear/insert/pop/remove, removes slice append and Taken, and keeps shared conditional clone. RFC 0054 adds the owner-only output transition and affine append-only OutputSpan<T> session with byte-specific raw FFI output. RFC 0064 fixes these spellings as the exact sequence vocabulary and rejects aliases. See slice.
std.strings	accepted target	RuneCursor, SplitCursor, LinesCursor	join	none	RFC 0061 adds ordinary affine rune traversal and checked zero-copy slice_bytes; owner growth is consuming append(str | rune)/reserve/clear. RFC 0064 reserves append for a complete text suffix and excludes sequence/raw-byte mutation aliases. Text is counted UTF-8 with U+0000 and no terminator promise. join accepts only an explicitly materialized [^str]. The checked-in source remains transitional.
std.time	mvp	Duration, Instant	ns, us, ms, sec, to_nanoseconds, now, now_realtime	TimeError	Duration construction with checked unit conversion; Instant/now provide monotonic clock readings and now_realtime the wall clock.
std.unicode	mvp	Decode	casing, grapheme, norm, utf8, utf16le, version	UnicodeError	Unicode facade over strict UTF-8/UTF-16LE primitives plus Unicode 17.0.0 normalization, grapheme clusters, case conversion, and case folding.
std.unicode.casing	mvp	Locale	fold, fold_into, lower, lower_into, title, title_into, upper, upper_into	none	Unicode 17.0.0 full case conversion and locale-independent full case folding.
std.unicode.grapheme	accepted target	Cursor, Cluster<region Source>	iter	none	Allocation-free Unicode 17.0.0 extended-grapheme traversal over valid str, yielding source-backed text and explicit byte ranges.
std.unicode.norm	mvp	Form	normalize, normalize_into, normalized	none	Unicode 17.0.0 NFC, NFD, NFKC, and NFKD normalization.
std.unicode.utf16le	mvp	none	valid, to_utf8_into, to_utf8	UnicodeError	UTF-16LE validation and UTF-8 conversion. Allocating conversion may throw AllocError.
std.unicode.utf8	accepted target	Decode	text, decode, encode, to_utf16le_into, to_utf16le	UnicodeError	text(Bytes) is the sole checked borrowed UTF-8 gate; Decode.value and encode use rune. U+0000 is accepted. Allocating transcoding may throw AllocError.