Repository navigation
Releases
AlxLib 1.6.1
Patch release — the archive decoder gets a single header probe, the encoder factories cap the block-size parameter, and the design docs shed their dated records.
One header probe: decoder::probe(stream) returns pktype{clan, cmps, encrypt, version} — the common head first, then each version from the newest down, the first to accept winning; every field is zero when no family claims the stream. decoder::create dispatches on the same probe, so the reader can no longer drift from the factory. The static is_encrypt(stream) / is_compress(stream) are gone; read the returned fields (the packed word is also available as valid()).
Block-size cap: the three encoder::create* factories refuse _blck_size of 4 GiB and above with badparams, the same style as the v2 iteration check.
Test anchors: a 256-byte AES-256-GCM known-answer vector exercises the eight-block CTR / four-way GHASH path, and v2 gains the truncation, trailer-tamper and whole-block-relocation cases.
Docs: the release log now lives in doc/migration.md; the design docs carry no dated records. §4.4 restates the v1 CRC as error detection — a known-plaintext attacker can forge, which is now a boundary — and §4.6/§4.5 correct the GCM query count and the header byte order.
No format change: v1 and v2 archives stay byte-identical, .axp and vtype are untouched, and the SONAME stays .so.1.6.
Assets: AlxLib-1.6.1-linux-x64-g845b899-slim.tar.gz (headers, the merged static library without debug info, docs and third-party notices) plus its .sha256.
AlxLib 1.5.0
Minor release — asynchronous delivery gains a delay, a management clear and nested service, with the host's priority band reserved.
Deliveries can be delayed: engine::yield and fwrap::callback::call take _delay_ms. A delayed delivery is stamped with its not-before time at enqueue, cannot be taken before it, and is made eligible by the heartbeat pass — which now also wakes a waiting yield(ms) window, so the window picks the delivery up at the delay instead of its own deadline. Expiry still counts from submission and can end a delivery before its delay does; timer precision is the heartbeat's period (no earlier than the delay, typically within 50 ms of it).
Queue management: engine::clr_yield(_priority, _maxcnt) settles queued deliveries without running them — oldest first, priority <= _priority, at most _maxcnt (0 = unlimited), each as YieldError("cleared"), and only while a run is in progress. The in-flight delivery is unaffected. The currying handle exposes the same clear as drop, clamped to the host-reserved band.
Nested service: a serviced call may call yield() itself and service the queue — the Qt processEvents pattern. Each level saves and restores the previous frame stack, so the caller's locals survive and the nested call still runs root-pose; each level keeps its own window, maxcnt and return count. engine_config::yield_nest caps the levels (default 64; 0 = unlimited); the level past the cap is the catchable script-level YieldError("nested yield").
The host's band is reserved: engine_config::yield_rsvprio marks every priority above it as host-only; a currying handle clamps both its delivery priority and its drop threshold down to it (default max_uint_32, so nothing is reserved until the host asks). The engine's own yield / clr_yield are unclamped, and fwrap itself carries no queue management.
Renames: engine_config::max_yield / set_max_yield are now yield_limit / set_yield_limit.
No opcode or AST change: vtype is untouched and .axp products need no recompilation. The minor release moves the SONAME to .so.1.5, so every host and link module must be rebuilt.
Build packages — AlxLib-1.5.0-linux-x64-geb3a68e-slim.tar.gz (+ .sha256): the public headers, the merged static library (lib/libalxlib.a) and the notices; the shared libraries and per-module archives stay in the developer package and are not published. No Windows packages accompany this release.
AlxLib 1.4.1
Minor release — a link names its own handle types, the host gains a type query surface, and the error classes split.
A link names its own handle types (1.4.0): fwrap::bind(uint_64 rid, const char* name, desc, view) — taken from LINK_LOAD only — registers the handle's type id (anyptr_ex<T>::rid, a compile-time constant) under a printable name with an optional summary and view payload. The table is per engine, committed only when the load entry returns normally, and a module's entries are dropped when its last instance goes. A second registration of the same id answers false; the link decides whether to raise.
The host can query: engine::type(v) answers the name the script's own type() gives — built-in names, then the owning link's registered name, then the host's set_type_extend callback, then "unknown"; engine::desc / engine::view answer the registered summary and payload (opaque to the engine). hook_info::wktype / wkdesc / wkview mirror all three inside a hook callback, so hkdt stays the host's own cookie.
fwrap is one interface with four implementations: native call, load, create, teardown. A call the context does not allow throws ContextError; the registration face returns bool — bind(name, fn[, area]) binds one native (creating an empty area when absent), bind(area, obj, methods) creates an area carrying the object (create-only, the object moving in on success), and wrap<T>(obj, area, methods) is exactly bind(area, anyptr_ex<T>::make(obj), methods).
The error classes split (1.4.1): link failures report LinkError (was ImportError); ImportError stays import-side; the fwrap misuse that used to be LinkError is now ContextError (id 16). engine::running() → is_running(), set_type_ex → set_type_extend(); anyptr gains a compile-time rid() and moves now leave a clean null handle.
Benchmark (2026-11-03): weighted GEOMEAN 206/311, recorded in doc/scpt/bench.md.
No opcode or AST change: vtype is untouched and .axp products need no recompilation. The minor release moves the SONAME to .so.1.4 and every link module must be rebuilt; the 1.4.1 patch keeps it.
Build packages — AlxLib-1.4.1-linux-x64-g3602919-slim.tar.gz (+ .sha256): the public headers, the merged static library (lib/libalxlib.a) and the notices; the shared libraries and per-module archives stay in the developer package and are not published. The Windows packages follow.
AlxLib 1.3.3
Patch release — the script engine's name lookup moves to the definition chain and gains the ^ activation anchor; link-load failures say why; and the shipped Linux bin/ is relocatable.
Name lookup follows the definition chain (1.3.3): a name resolves from the frame where its def was declared, not from the caller's stack, and every teardown path unwinds frames inner-to-outer. A chain may start with ^ / ^^, which moves the lookup to the enclosing callable's declaration frame (one level per ^). The four dot-path operations share one failure table, so a read, write, delete and call on the same shape report the same error, and a qualified call that misses now says where the name actually lives.
Link-load failures name the loader's reason: a failed link reports link error: <op> failed: <path>: <detail> on the on_csys channel and Cannot link: <path>: <detail> to the script — the platform loader's own text (dlerror() on Linux; the GetLastError() code plus its system message on Windows, with a short hint for a missing dependency, an architecture mismatch or a failed DllMain).
The shipped libraries carry $ORIGIN: every module DSO in the Linux package now resolves its siblings relative to itself (DT_RUNPATH is not transitive), so bin/ runs from any location; the example link modules link the engine and carry a relative runpath. doc/scpt/notice.md records the Linux and Windows deployment layouts — flat or shell + body, the /MD runtime, the dllexport entry points and the x64 contract.
The Lza GUI moves out: the example and its MSVC project leave this repository for the ALzapk repository.
Benchmark (2026-11-02): weighted GEOMEAN 206/311 (full-workload / pure-script weights), recorded in doc/scpt/bench.md.
No opcode or AST change: vtype is untouched, .axp products need no recompilation, and the SONAME stays .so.1.3.
Build packages — AlxLib-1.3.3-linux-x64-g80d2027-slim.tar.gz (+ .sha256): the public headers, the merged static library (lib/libalxlib.a, debug info stripped) and the notices; the shared libraries and per-module archives stay in the developer package and are not published. AlxLib-1.3.3-win-x64-g80d2027.zip (+ .sha256): the four DLLs, their import libraries, the headers and the docs, with AlxLib-1.3.3-win-x64-g80d2027.pdb.zip (+ .sha256) carrying the PDBs.
AlxLib 1.3.2
Patch release — the child process's whole tree, the debug hook's scalar position and the send-queue depth, and the first Windows binaries.
process_ctrl owns the child's tree (1.3.2): every start now runs the child in a tree of its own — POSIX a process group (setpgid on both sides of the fork), Windows a job object created for every start rather than only when process_limits asked for one — and kill() / destruction signal that group / terminate that job, so what the child started goes with it, including the descendants left behind by a child that had already exited. terminate() still signals the direct child only; a descendant that calls setsid() or breaks away from the job is beyond the platform's reach, as documented. status() stops reaping: it peeks with waitid(…, WNOHANG | WNOWAIT) and leaves an exited POSIX child a zombie until kill(), the only reaping point now — that is what keeps the pid, and with it the process group id kill() signals, reserved to the object, so a late kill(-pgid) can never fire into a recycled group. Hosts that relied on status() reaping call kill() (the destructor already does); the outcome keeps coming back through status(), and the child table shows a defunct entry until then.
hook_info gains scalar positions and a path reference: wkdt_row() / wkdt_col() read the state's position slot without building the varmap that wkdt_pos() allocates (≈ 250 ns a statement — the GUI host measured a 2.5× debug mode around it), and wken_path(_e) returns the resolved full path by reference, empty for the root, where wken_file() returns a copy and the position's file field only the basename. Non-virtual, no vtable slot, no hook_info field, no opcode or vtype change. comm_ex gains the queue depth: comm_ex(transmit*, uint_64 _queue_limit = 0x80) forwards comm's existing send-queue bound to the constructor, so a host pushing large snapshots can widen it; the default and every send/receive semantic are unchanged.
The Windows side builds and ships: the MSVC Release|x64 solution builds again and all four suites go green — the toolhelp32 enumeration names PROCESSENTRY32W / Process32FirstW / Process32NextW, which are the only spellings the Windows SDK ships, and the <charconv> include gate follows the library's own CPP_VERSION macro instead of __cplusplus, which MSVC leaves at 199711L without /Zc:__cplusplus. This is the first release to carry a win-x64 package, and it is DLL-based: the four DLLs with their import libraries (the lib/*.lib members name only the DLLs they bind to), the public headers and the docs. No static library is shipped on Windows — the DLL shape is the one supported form, keeping /MD and /MT out of the picture — and the PDBs travel as a separate archive.
Migration notes: no opcode or AST change anywhere in this, so vtype is untouched and .axp products need no recompilation; no symbol changed its home, the SONAME stays .so.1.3, and the library version moves 1.3.1 → 1.3.2 — a patch. One host-visible behaviour change: process_ctrl::status() no longer reaps, so a host that waited on it for the child's disappearance should call kill(). The migration record is in doc/scpt/design.md §10.1.
Build packages — AlxLib-1.3.2-linux-x64-g169f9ef-slim.tar.gz (+ .sha256): the public headers, the merged static library (lib/libalxlib.a, debug info stripped) and the notices; the shared libraries and per-module archives stay in the developer package and are not published. AlxLib-1.3.2-win-x64-g169f9ef.zip (+ .sha256): the four DLLs, their import libraries, the headers and the docs, with AlxLib-1.3.2-win-x64-g169f9ef.pdb.zip (+ .sha256) carrying the PDBs.
AlxLib 1.3.1
Minor release — the yield service, plus the 1.3.1 patch. Hosts linking the shared libraries must relink: the SONAME moves to .so.1.3.
The yield point (1.3.0): yield(time_ms = 0, maxcnt = 0) joins the language — the one script-written service point, where the engine takes calls delivered from other threads. engine::yield queues a call to a def by name (late binding), fwrap::currying mints a caller-owned delivery handle for a link's communication threads, and set_max_yield / engine_config::max_yield bound the queue (default 256, 0 = unlimited). A serviced call runs under root pose — it sees the root variables, not the main walk's locals — through the same entry ladder call() uses, and every outcome travels inside its future (value, script error, no main fiber, yield full, expired, not executed, InterruptedError); a future is never broken. A nested yield() raises a script-level YieldError("nested yield") that the serviced call may catch; a yield during module init is a script-level error. A 50 ms background pass (the script layer's first thread) liquidates expired deliveries, and its on_csys entries are the only ones emitted off an engine's own thread. error_type gains YieldError, O_YIELD appends after O_DEBUG (no renumbering), and result moves to the script namespace with engine::result kept as an alias.
A failed run no longer resets (1.3.0): an execution-time failure only ends that run — root variables, defs and loaded modules survive; reset() is the only reaper. This is what lets a serviced call fail without taking the host's state with it.
1.3.1: import/link stop swallowing ResourceError / MemoryError / NativeError from a module init or a link's load/create entry — the failure now reaches an enclosing script try or the entry's ladder, and a throwing load/create surfaces as NativeError instead of a silent success. The yield queue's internals settle their names, and a documentation audit round corrects the reference where it described behaviour the engine does not have. No opcode or AST change; old .axp products run unchanged.
Version / SONAME: the library steps 1.2.2 → 1.3.0 → 1.3.1. The minor bump moves the SONAME to .so.1.3; 1.3.1 is a patch and keeps it.
AlxLib 1.2.2
Patch release — carried over v1.1.0 it also holds the unreleased 1.2.0 line, so the jump spans two version steps.
The script semantics redo and the base descent (1.2.0): delete dispatches at run time — the module top layer reaches the module store, a frame deletes its own layer only, and a literal / call result / slice target is a TypeError; link data is shielded at any depth and an area's native table is not writable; a handle's m_parent is the entity that holds it, rebound recursively; = is always a store and op= resolves its target once after the RHS (P0145R3 order); bytes/string elements are int 0–255 and read-write, [null] reads the size and writes an append, and the four linear containers take a same-type count-matched slice assignment; the host probe resolves to a slot or nothing (fwrap::nload → iload); '...' is a code-point literal now ('A' = 65), with '' and multi-point forms compile errors; and aes, verify and datetime moved from libalxcore.so to libalxbase.so — the host must relink, the SONAME going .so.1.1 → .so.1.2.
The 1.2.2 round: a call scans its arguments first, then the callee's path expressions run and the address is taken — nothing runs script code between the address and the invoke; @ is an object alias, so a detour that evaluates expressions inside the reflection string (a call, a slice) is refused with NameError; a callable and a link area are not values — a copy throws wherever the walk attempts one — while the engine's own duplications take explicit clones, and a callable slot refuses assignment through every port (the @ and :: ports included); an import/link alias is an ordinary value, a copy of the instance re-bound at its binding site, with only a link's sub-data left opaque; a link copy clones its data and re-runs LINK_CREATE; exec() refuses a result holding an anyptr (released on the spot, the engine reset) while call() stays the unrestricted channel, and the engine-state rule — a run that fails during execution resets the engine — is written down, call() discarding an idle interrupt at its entry like exec(); and anyptr's copy assignment leaves a clean null handle when the copy throws.
Migration notes: no opcode or AST change anywhere in this, so vtype is untouched and .axp products need no recompilation; the SONAME stays .so.1.2. One source-level break: an existing source that used '...' as a string must be rewritten — a multi-point form is a compile error, a single-point one silently changes value. The migration record is in doc/scpt/design.md §10.1.
Build package — AlxLib-1.2.2-linux-x64-g58e1d97-slim.tar.gz (+ .sha256, 7.9 MB): the public headers, the merged static library (lib/libalxlib.a, debug info stripped), and the notices — the package the AlxRun README unpacks into lib/alxlib/. The shared libraries and per-module archives stay in the developer package and are not published; the upstream libraries are supplied by the caller.
AlxLib 1.1.0
Minor release.
type() asks the host before "unknown": engine::set_type_ex(const char* (*)(const variant&, void*), void* = nullptr) names the values the script layer has no name of its own for — an object a host handed over, and a value of a variant type it does not model. Both used to dead-end ("anyptr" and "unknown"); a null or empty answer, or no callback at all, now leaves "unknown". The diagnostic messages that name a value ("Expected int, got X" and the like) never ask and keep saying "unknown". Minor, not patch: an added virtual (after set_pipe) and two appended config fields make the SONAME go .so.1.0 → .so.1.1, so a host has to relink; no opcode or AST change, so .axp products need no recompilation. The migration record is in doc/scpt/design.md §10.1.
Build package — AlxLib-1.1.0-linux-x64-g432bcb7-slim.tar.gz (+ .sha256, 7.9 MB): the public headers, the merged static library (lib/libalxlib.a, debug info stripped), and the notices — the package the AlxRun README unpacks into lib/alxlib/. The shared libraries and per-module archives stay in the developer package and are not published; the upstream libraries are supplied by the caller.
AlxLib 1.0.2
Patch release.
type() names handles now and never answers null: a callable handle (a module function, a link namespace or area function) reports "func", a host object "anyptr", an empty handle "null", a namespace handle "import" / "link" / "area", and a value of a variant type the script layer does not model reports "unknown". The indirect-call message stopped leaking mangled C++ names (@5() said got x, it says got int). No ABI or opcode change — a set built against 1.0.1 loads this one without relinking, and .axp products need no recompilation. The migration record is in doc/scpt/design.md §10.1.
Build package — AlxLib-1.0.2-linux-x64-gd546959-slim.tar.gz (+ .sha256, 7.9 MB): the public headers, the merged static library (lib/libalxlib.a, debug info stripped), and the notices — the package the AlxRun README unpacks into lib/alxlib/. The shared libraries and per-module archives stay in the developer package and are not published; the upstream libraries are supplied by the caller.
AlxLib 1.0.1
First public release.
A general-purpose C++ library (C++11 and later) in four layers, MIT-licensed:
- alxbase — basic types (
bytes,variant), serialization, JSON/XML/CSV, string utilities, factory - alxcore — file I/O, crypto (AES), compression (LZ4/Gzip/zstd), SQLite, images, thread pool, logger, fiber
- alxscpt — script engine (lex → parse → compile → execute)
- alxcomm — TCP/UDP transport, HTTP server/client, RPC framework (TLS via OpenSSL)
The third-party inventory — seven link-time libraries, the nested licenses, and the OpenSSL/GPLv2 note — is in THIRD-PARTY.md; full texts ship in licenses/. The upstream libraries are supplied by the caller, not shipped here — versions, build notes and sha256 are in 3rdpty/README.md.
cmake -B build -DALXLIB_OPT_LEVEL=3 -DBUILD_TESTS=ON
cmake --build build -j7Docs per module (API manual / design / known limits) are linked from the README.
Build package — AlxLib-1.0.1-linux-x64-g62e3cfb-slim.tar.gz (+ .sha256, 7.5 MB): the public headers, the merged static library (lib/libalxlib.a, debug info stripped), and the notices — the package the AlxRun README unpacks into lib/alxlib/. The shared libraries and per-module archives stay in the developer package and are not published; the upstream libraries are supplied by the caller, as above.