Version 2.0.0

[Summary]

StormByte System is the C++26 process, device and host layer of the StormByte suite.

It depends directly on StormByte Base 2.0.0 or newer. This repository is not Base, Buffer, Config, Crypto, Database, Logger, Multimedia or Network.

Spawn children with piped stdin/stdout/stderr, classify the medium behind a path, resolve directories and the current executable, inspect the machine, name the calling thread, and expand environment strings. POSIX and Windows stay behind one API. Failures are StormByte::Error::Fault in a per-type domain (StormByte.System.*). Nothing in this module throws. Text that crosses a DLL boundary is StormByte::Safe::String / StormByte::Safe::WString, not std::string by value.

From 2.0.0, original System sources are dual-licensed: GNU Lesser General Public License v3.0 or later, or a commercial license from the copyright holder. That change does not cover other StormByte modules or third-party material under thirdparty/ (including bundled StormByte Base).

If you landed here from a release link and have not read the tree:

• What this module is, how to build it, and short examples: README.md
• License: dual license LGPL-3.0-or-later or commercial, LICENSE

Added

• Device: classify the medium behind a path (Kind, Access bitmask, nominal Throughput, suggested Window).
  • Copyable; stores only the caller accessor as StormByte::Safe::String.
  • Probe is on-demand. operator bool is probe success, not permission.
  • Errors are StormByte::System::Device::Error in domain StormByte.System.Device, held as StormByte::Error::Fault.
• Directory: current, home, temporary and current-executable directories. bool + out String; LastError() is TLS in this module.
• File: Temporary(prefix, suffix) creates an empty file the caller unlinks; CurrentExecutable is the running image.
• Host: name, architecture, CPU brand, OS, kernel, page size, physical/available memory, logical processors, process bitness.
• ThisThread: Sleep; get/set thread name (TooLong if the platform limit is exceeded; the name is not truncated).
• Dual license on original System sources: LGPL-3.0-or-later or commercial (LICENSE + COPYING.LGPLv3).
• Shared vs static follows CMake BUILD_SHARED_LIBS (declared in lib/, default ON). There is no STORMBYTE_SYSTEM_SHARED CMake option. When the library is shared, the compile definition STORMBYTE_SYSTEM_SHARED is still set so visibility.h can distinguish dllexport / dllimport / static. Vendored StormByte Base follows the same BUILD_SHARED_LIBS mode and is configured with ENABLE_TEST=OFF.

Changed

• Breaking: Windows Process::Pid() returns only the child process identifier (DWORD); process and thread handles remain private to the Process owner.
• Breaking: Process no longer throws. Spawn, wait and stdin failures are StormByte::System::Process::Error in domain StormByte.System.Process, held as Fault().
  • operator bool is true only while a child is live (RUNNING or SUSPENDED).
  • Timed Wait sets TimedOut and leaves the child running. A second wait after a successful reap sets AlreadyExited.
  • A failed stdin write sets BrokenPipe.
• Breaking: Variable::Expand returns StormByte::Safe::String. On Windows, a failed ExpandEnvironmentStringsW returns the original text (same as a missing UNIX home).
• Breaking: Process constructors take a UTF-8 StormByte::Safe::String executable path and StormByte::Safe::Vector<StormByte::Safe::String> arguments. Native filesystem-path conversion stays inside System, so neither std::filesystem::path nor std::vector crosses the DLL boundary.
• Pipe construction and I/O no longer throw. Invalid pipes convert to false.
• Public text across a DLL boundary uses StormByte::Safe::String / StormByte::Safe::WString; borrowed views carry explicit lengths. Native C-string copies are allocated and destroyed inside System, without relying on NUL termination in Base text buffers.
• Breaking: System vendors StormByte Base 2.0.0 directly instead of StormByte-String and exposes Base's StormByte::Safe owned-text types in its public API. Headers include StormByte/safe/*.hxx instead of StormByte/string/*.hxx, StormByte/cstring.hxx and StormByte/wcstring.hxx.
• Visibility macros follow Base/Logger (EXPORTS / STORMBYTE_SYSTEM_SHARED / static empty).
• Windows Device probe links iphlpapi and ws2_32. Host CPU name links advapi32. macOS Device probe links IOKit and CoreFoundation.
• Breaking: Host::PageSize, PhysicalMemory and AvailableMemory return ByteSize. They are octet lengths.
• Breaking: Device::Window is ByteSize. Device::Throughput stores octets per second as ByteSize, not std::size_t.
• Breaking: Process::operator>> and Stderr take StormByte::Safe::String, not std::string. The captured text is owned by Base. operator<<(std::ostream&, const Process&) is STORMBYTE_FORCE_INLINE, so the stream buffer grows in the caller. operator<< on Process and Pipe accepts std::string_view and String. operator>> stays String only: a view cannot own the bytes that were read.
• Process path. Both constructors copy UTF-8 text into module-owned native path and argument storage; std::filesystem::path remains behind the private implementation.
• Process owns its private implementation through StormByte::Safe::Unique, allocated and freed on Base's heap.

Fixed

• Process lifecycle and errors
  • Construction and forwarding-thread exceptions are contained; startup failures after private state exists, plus native wait/suspend/resume failures, are reported through the Process error domain.
  • Interrupted POSIX timed waits retry EINTR while continuing to enforce the requested deadline.
  • The Windows suspend/resume regression uses an explicit stdin barrier and exit status.
  • The forwarding-thread owner is allocated before the thread starts, and the POSIX argument vector is prepared before fork, preventing standard-library exceptions from escaping noexcept construction or reaching the forked child.
  • Moving a failed or moved-from Process no longer carries a stale initialization error.
• Filesystem and device errors
  • Directory and File operations retain permission and missing-path causes in their own error domains and contain filesystem exceptions in LastError() results.
  • A denied symlink target is reported as Permission, not BrokenSymlink; broken targets remain distinguishable on POSIX and Windows.
  • File temporary creation maps missing and inaccessible temporary directories to the corresponding File errors.
• Public value and resource contracts
  • Device Access, Throughput and Window are registered as MaybeSafe values for Base safe collections.
  • The Device(filesystem::path) adapter converts a native view in the caller module; probing contains conversion failures as ProbeFailed.
  • Windows thread-name buffers are released through an owner even if conversion fails.
  • Windows environment expansion, temporary-file creation and thread naming materialize module-local NUL-terminated strings before calling native APIs; bounded views do not expose trailing text or require a terminator beyond their range.
  • The Windows bounded-environment regression uses _dupenv_s with module-local RAII cleanup to preserve the previous value without deprecated CRT calls or suppressing warnings.

Removed

• Breaking: Process stdin and Variable::Expand overloads for Base's removed CString / WCString types. Use String, WString or the corresponding length-aware views.
• Breaking: StormByte/system/exception.hxx (Exception, FileIOError, ExecutableNotFound, ProcessCreationError).
• Breaking: StormByte::System::Error and StormByte/system/error.hxx (domain StormByte.System). Device, Process, Directory, File, Host and ThisThread keep their own domains.

Version 1.1.0

[Summary]

StormByte System is the C++26 process and environment layer of the StormByte suite.

Dependency baseline: StormByte (base) 1.1.0.

Spawn children with piped stdin/stdout/stderr, chain them, suspend/resume, and expand environment strings. POSIX and Windows stay behind one API.

Changed

• Public process behavior
  • Ported System exception messages to the StormByte::Component format and added ProcessCreationError for process creation failures.
  • Added a public timed Wait(std::chrono::milliseconds) overload; the existing untimed overload remains unchanged.
• Process pipeline internals
  • Moved forwarding into the internal Pipe abstraction while preserving buffered and future output.
  • Moved Process state into the private process implementation header, reducing public-header ABI exposure.
• Dependencies and build configuration
  • Updated the StormByte/base dependency to 1.1.0.
  • Switched Windows release optimization handling to CMake interprocedural optimization without duplicate manual compiler/linker flags.

Fixed

• Pipe and process lifecycle
  • Pipe construction now checks platform errors, normalizes UNIX descriptors, and moved pipes invalidate their source endpoints.
  • Pipe reads, writes, polling, EOF handling, and descriptor binding now distinguish interruption, EOF, and failure.
  • Process pipeline forwarding retains pipe ownership independently of Process lifetime, supports safe reconnection, and cancels without cross-thread descriptor closure.
  • Process waiting no longer deadlocks on downstream backpressure; lifecycle joins handle unexpected thread errors without escaping noexcept cleanup paths.
  • Direct writes, interrupted waits, and Windows wait failures now preserve error and ownership semantics.
• Process startup and platform handling
  • UNIX startup reports execvp failures to the parent and throws the appropriate exception eagerly.
  • Windows startup quotes command-line arguments and distinguishes missing executables from other creation failures.
  • Environment expansion handles missing home directories safely, expands only leading ~ paths, and grows Windows buffers as needed.
• Regression coverage
  • Added coverage for pipelines, process moves, signal termination, interrupted waits, descriptor reuse, consumer exit, direct write failures, and oversized Windows environment expansion.
• CI portability
  • Fixed Windows-only Process implementation initialization.
  • Made UNIX process tests resolve utilities through PATH for macOS portability.

Version 1.0.0

[Summary]

StormByte System is the C++26 process and environment layer of the StormByte suite.

Spawn children with piped stdin/stdout/stderr, chain them, suspend/resume, and expand environment strings. POSIX and Windows stay behind one API.

Initial public release of StormByte-System.

Added

• Process: run external programs with piped stdin / stdout / stderr
  • Move-only ownership; starts on construction
  • Wait() for exit code (blocking, no timeout)
  • Suspend() / Resume()
  • Stream operators: write stdin, read stdout, << System::EoF to close stdin
  • Process chaining (p1 >> p2) via background forwarder
  • Stderr() to read the stderr pipe
  • Cross-platform (POSIX fork/exec and Windows CreateProcessW)
• Pipe (internal): anonymous pipes for IPC (UNIX pipe/pipe2, Windows CreatePipe)
  • Atomic chunked writes, bind/dup helpers, handle inheritance flags on Windows
• Variable: expand environment strings (Windows ExpandEnvironmentStrings; UNIX ~ → home)
• Exceptions: Exception, FileIOError, ExecutableNotFound
• Unit tests for Linux, macOS and Windows (pipelines, stdin, exit codes, move)

Fixed

• Process move no longer double-waits the same child (ownership is fully transferred)
• Failed execvp in the child uses _exit(127) instead of throwing across fork
• Removed unimplemented Pipe::BindRead(Pipe&) / BindWrite(Pipe&) declarations
• Pipes owned with std::unique_ptr instead of raw new/delete
• SIGPIPE ignored once per process (not on every Pipe construction)
• WriteAtomic treats empty input as success
• Windows command line built without a trailing space

Notes

• On UNIX, if the executable cannot be started, the child exits with status 127; the parent does not throw from the child path.
• Wait() has no timeout; it blocks until the process ends.