Source revision 598a46ec894e83b4c069bfc34233abeb337bea07. Qualified by the
successful package CI run.
The complete changelog includes earlier releases.
Version 1.20.5 [changed] - compiler/semantic tooling: keep generated unnamed parameters without a source range or macro origin outside identifier-hint inputs; retain complete binding ownership for real source and macro hints, with a function-pointer regression in the normal semantic-sidecar runner. - compiler/semantic tooling: add requested hint, declarator-list, consumed-keyword and macro-access observations without enabling their collection by default; retain complete FOR-step headers, external-object linkage, distinct declaration macro origins and PUBLIC UNION identity; provide an explicit stable datatype export ABI and withhold integer values wider than the existing 64-bit value carrier. - compiler/128-bit integers: add Integer<128> and UInteger<128> scalar types with arithmetic, comparisons, bit operations, conversions, calls and FOR counters; use native C/LLVM operations where supported and portable two-word runtime lowering elsewhere, document target-specific C interoperability, and add layout, argument/return ABI and boundary regressions. - compiler/thread-local storage: add THREAD LOCAL declarations with separate values and constant initialization per thread, runtime-managed storage for native GAS definitions, and C TLS interoperability; restrict native GAS C imports to Linux executables, reject managed types and dynamic initializers, retain thread-local semantic facts, and add manual examples and worker-isolation tests. - compiler/EXTERN: allow forward-declared object types in external scalar declarations and preserve address-taking and BYREF calls before the type is complete; reject value access, assignment, indexing, member access and incomplete array elements with a diagnostic, with cross-language backend regressions. - gfxlib3/screen capture: add Gfx3ScreenCapture for synchronous regional capture into a CPU FB.IMAGE and Gfx3SurfaceCopyFromScreen for GPU-resident copies from the current work page; preserve pending drawing and authoritative SCREENLOCK shadow writes, validate bounds and surface capabilities, and add page/copy regressions. - gfxlib3/OpenGL: include bounded opaque filled and outline rectangles in ordered mixed batches with points, lines and ellipses; preserve exact clipping, line styles and last-writer order through GPU winner/resolve passes, retain the existing paths for larger or blended primitives, and add overlap regressions. - tests/core language: add a strict keyword/directive discovery check to the standard language-test gate, an evidence inventory and focused FBLite, preprocessor, linkage, legacy-control, reserved-keyword and runtime tests; include serialization round trips in normal log tests and keep generated failure inventories out of version control. - rtlib/Amiga allocator: retain bounded spare capacity across realloc growth and small shrinks to reduce repeated string and REDIM PRESERVE copies, retry exact-size allocation when spare-capacity reservation fails, and guard Exec's final allocation rounding; add an instrumented native probe for growth, shrink and failure fallback. - Amiga qualification: supply the serialization example's declared filename argument and record the completed post-restructure fbctests and self-contained Exampleageddon runs; retain corpus, pixel-comparison and checkpoint evidence separately from unfinished full-recording qualification. - external libraries and examples: select the System V libffi ABI on Haiku, link libintl on FreeBSD and Haiku, preserve native C unsigned-long plural counts, and select libc++ for native FreeBSD/Darwin C++ example helpers; add native ABI and optional-SDK coverage checks, and complete Debian optional development-package lists with compatible curl backend alternatives. - semantic transport reader: share bounded binary framing between text-record and direct-field iteration; preserve encoded values, dictionary ownership and indexed offsets while allowing native consumers to avoid intermediate TSV reconstruction. - maintenance refinements: compare warning reports without modifying references, check source-guide links and fresh rendered pages, reject incomplete artifact scans, track selected tool replacements and bootstrap configurations, isolate compiler/library outputs with BUILD_ROOT, and enforce runtime-before-graphics mode locking with a native regression. - build consolidation: track effective normal compiler/runtime commands per variant, rebuild partially changed objects when reverting flags after failure, preserve the previous compiler after a failed link, use the selected GNU Make and portable warning normalization on BSD hosts, and reject generated analyzer dumps in maintained source trees; remove tracked generated dumps/lists and add configuration/failure regressions. - source documentation: add repository and Wakka manual source-tree guides with compiler, core runtime, graphics, sound, target-tool and test pages; link both manual tables of contents, the documentation index, and the src entry point; update compiler module paths to the current subsystem layout. - build system: relink compiler variants after embedded runtime changes, order parallel distribution staging and include nested headers, support standalone distribution ZIPs, record only copied include files for uninstall, preserve failed uninstall manifests, and publish archives only after successful indexing; add isolated Make contract regressions to quick/full workflows. - build/toolchains: separate native host probing from target CC, reject missing inferred cross compilers before compilation, gate parallel object recipes on prerequisites, resolve x86 multilib identity before layout, forward C++/assembly preprocessor flags, and track successfully published archive members so source removals and failed retries remain correct across filesystem timestamp granularities. - build/tests: preserve DOS provider-enabled thread objects in link manifests, propagate sanity-check failures, reject semantic records after completion footers, validate bootstrap producer status and source emission, preserve unrelated release archives during cleanup, and restore packaging's bootstrap-source cleanup alias. - documentation/examples builds: serialize shared generators and recursive tool builds, unify native executable suffixes, track manual cache and helper interface changes, recreate ZIPs after page removal, verify fresh CHM output, share distribution runtime payload ownership, bound example cleanup arguments, and correct standalone installer/import-library aliases. - compiler test harness: reconstruct failed-test selections from saved mode headers, preserve passing logs and objects during retries, keep retry summaries separate, regenerate cleanup manifests independently, retain filenames in single-failure details with matching Haiku grep support, and quote Windows compiler paths for GNU timeout regression checks. - gfxlib maintenance: group shared gfxlib2/gfxlib3 implementations by responsibility, collect native adapters and CPU kernels under drivers/, split OpenGL and Vulkan into independent implementation units behind backend-private contracts, document ownership and synchronization, and check source selection, includes and archive-member uniqueness without changing the graphics ABI. - rtlib maintenance: group portable implementations into explicit subsystems and native layers under drivers/, keep platform replacement and runtime ABI contracts, document lifecycle, ownership and locking, and add source/include/archive-member checks to quick/full workflows. - Exampleageddon: keep SETDATE and SETTIME examples compile-only, including with --run-all, so privileged test accounts cannot change the host clock; cover classification and the actual run decision with regression tests. - rtlib/services: add BI interfaces for checked Windows, Linux/BSD and Android notifications and a small caller-owned idle loop with bounded waits, monotonic deadlines and explicit stop behavior; keep native context ownership, Android permissions and unavailable backends explicit. - gfxlib2/gfxlib3 drops: add an opt-in shared BI interface and pointer-free SCREENEVENT metadata for bounded copied payloads; receive Windows shell file drops and X11 local-file or UTF-8 text drops, with transfer refusal, timeout and cleanup checks. - examples/services: demonstrate notification lifetime, cooperative and worker polling, checked secure-random bytes and unbiased bounded selection; report an unavailable secure-random provider without treating that expected target limitation as an example failure, and add a common graphics drop receiver and focused native protocol checks without changing Templari or installed SDK archives. - rtlib/secure randomness: add a checked API with bounded requests, full-span failure wiping and no RND fallback; use CNG on Windows, getrandom on Linux/Android and FreeBSD 12+, arc4random_buf on macOS, OpenBSD, DragonFlyBSD and NetBSD 6.0+, checked RDRAND on Haiku x86-64, and the validated XLRNG$ protocol on extended DOS; unsupported targets report unavailable, with native and DOS checks plus private MT archive staging that preserves installed SDK archives. - packaging/Slackware: retry transient DNS failures during CI dependency downloads with three bounded Wget attempts, preserving existing download options and package checksum/signature checks while leaving native network policy unchanged. - packaging/Arch Linux: share bounded pacman retries with MSYS2 for repository updates, build dependencies and cross-sysroot downloads, reusing cached packages after transient mirror or DNS failures while keeping exhausted transactions fatal. - gfxlib2/Amiga presentation: cache unchanged planar source rows when memory is available, retry incomplete native transfers, invalidate on refresh and restore private-screen canvases after WINDOWTITLE; cover cached, uncached and damaged-window paths. - gfxlib2 events: poll foreground drivers before SCREENEVENT queries and peeks so queued native input is delivered without an earlier INKEY or MULTIKEY call; retain queue-lock ordering and native input regressions. - gfxlib2 legacy images: match BASIC's low-bit legacy header layout on big-endian C ABIs and decode custom-font dimensions as native 16-bit words; cover image metadata, PUT pixels and explicit or inherited font depths. - rtlib/Amiga directories: route CHDIR through native path normalization and supply a valid empty C string for unallocated BASIC strings; cover parent traversal, backslashes and relative file lookup. - rtlib/Amiga formatting: forward sprintf to newlib's vsprintf so promoted 32-bit arguments, return counts and DATE$/TIME$ retain the expected C ABI; add formatting regressions shared with native hosts. - Amiga qualification: require an authenticated X11 handshake from the owned virtual display, keep emulator joystick mappings from consuming cursor keys, extend native graphics and I/O probes, and document presentation checks and provider limits. - compiler semantic primitive types: retain accepted primitive tokens, selected target datatypes and physical or macro origins with bounded module occurrence counts; validate optional full-model observations through the existing schema-27 binary and text transports. - compiler semantic header and macro origins: preserve constructor, destructor and operator header tokens for ABI observations, and accept source-selected ASSERT/ASSERTWARN runtime calls only when their macro reference and runtime target agree; keep generated helpers without source references unlinked. - compiler semantic indexing: retain the selected overloaded index operator through its implicit BYREF result dereference while preserving raw AST types, explicit dereferences and ordinary BYREF call observations. - build/compiler semantic lint: permit dedicated external result directories only by explicit option, stop after a retained or newly completed failure when requested, and report accepted, failed, selected and unrecorded roots without claiming incomplete coverage is complete. - compiler semantic reader snapshots: include the primitive-type validator in the frozen reader dependencies so isolated binary/text consumers import successfully after the new observation family is added. - compiler source structure: use the rooted tooling include for primitive-type observations and complete the source/header ownership documentation required by the canonical compiler structure check. - gfxlib2/RISC OS: keep native Wimp presentation separate from shared WINDOW coordinate mapping so both implementations reach the target archive; retain the LINE overflow regression and check both modules through the canonical Make source graph. - compiler semantic primitive types: retain explicitly unverified physical locations as noneditable observations when legacy or malformed source bytes cannot be mapped; keep missing origins and fabricated byte coordinates rejected, with binary/text and encoding regressions. - gfxlib2/LINE: reject nonfinite and unrepresentable transformed endpoints before integer conversion and clipping; retain valid LINE/B/BF rendering and the void ABI, with host/native regressions for every endpoint position and WINDOW overflow. - gfxlib2 input: poll foreground event drivers before MULTIKEY reads cached key state, matching GETMOUSE and INKEY; cover queued native presses/releases and real Escape input in delay-only loops on Amiga. - rtlib/Amiga console: initialize raw terminal handling only for interactive input/output handles, keeping redirected LINE INPUT, SLEEP, GETKEY and EOF on the shared stdio fallback; cover buffered read-ahead and unchanged ToyBASIC execution. - Amiga software arithmetic: repair single addition overflow and infinity signs, tiny double signs and exact cancellation, double division classification and signed infinity, and division guard/sticky bits; add 60,000 hardware-oracle comparisons across both operand signs and retain all existing native probes. - compiler semantic members: add optional full-model coverage for selected non-field members, including methods, static data, constants and nested enums; preserve object/type/symbol roles and original receivers through inherited and implicit THIS calls, bind only the selected overload, and validate immutable occurrence counts independently of field coverage. - compiler semantic transport verification: generate and check the producer/consumer record contract, reject unsupported required capabilities and malformed or incomplete frames, and add independent binary/text, reduced-mode, corruption and cache-invalidation checks without changing ordinary compiler emission. - documentation/semantic integration: document companion fblint artifact and finding caches, compiler/request/source hashes, include-shadowing invalidation, bounded storage and native Windows/Linux/Haiku/DOS launch paths; mark models using volatile date, time or command-line macros unavailable for persistent reuse and exclude semantic caches from source synchronization. - compiler semantic construction: retain counted implicit and temporary constructor choices even when there is no editable callee range, including selected conversions into trivial BYVAL UDT parameters; record REDIM's selected runtime constructor after successful lowering, and validate binary/text parity, complete module closure and reduced-mode exclusions. - compiler semantic numeric inputs: transport original numeric payloads through nested macro arguments and replacement offsets, distinguish source, transported and newly generated floating text, and retain inferred VAR initializer ownership before its symbol exists. - compiler semantic expression coverage: count captured and exported operands and parsed IIF occurrences per statement, mark incomplete inputs unavailable, retain MID's written arguments separately from its generated default length, and keep array-dimension expressions in expression-only output. - compiler/runtime serialization format: define the little-endian FBS1 logical schema independently of native padding, addresses and INTEGER width; preserve embedded-NUL strings, packed UDT members, fixed/dynamic array bounds and empty descriptors, and reject incompatible schemas or out-of-range cross-width values before replacing the destination. - compiler/runtime serialization boundaries: reject unsupported pointer graphs, BYREF fields, unions, inheritance, non-public data, wide/UTF-8 string types and user-defined UDT lifecycle operations at compilation; keep existing GET/PUT and native layouts unchanged and provide application-version migration and file/array examples. - bindings/libffi and JNI: update modern x86 libffi trampoline sizes and closure alignment, use Windows DLL data imports with a static-build override, and correct JNI's 32-bit jint and pointer-returning critical-array/direct-buffer entries. - bindings/native library layouts: correct Win64 GMP limb widths, QuickLZ's fixed 32-bit hash offsets, big_int and SpiderMonkey scalar layouts, native libjit sizes and configured floating storage, and PDFlib's C integer widths and allocator/output callback signatures. - bindings/library selection: support IUP's selected GTK2/GTK3 backend, Haiku's BCUnit library, FreeBSD's Lua/MariaDB/libc++ names, explicit GRX X11 selection and GSL CBLAS linkage; add the opt-in BASSMOD_21 attribute API and make GD/JPEG declarations coexist with existing CRT and Windows types. - example verification: add native GTK2/GTK3, GooCanvas and IUP window/callback checks, controlled OpenAL and PortAudio failure fixtures, and scalar/SIMD Linux sound-write regressions; allow genuine ALSA/PulseAudio sfx checks with an owned private PulseAudio context and distinguish decoding or metadata checks from playback in receipts. - build/exampleageddon: classify additional external-library directories and unsupported DOS THREADCALL/timer examples explicitly, and add a six-target comparison report for Win32, Win64, Linux, FreeBSD, Haiku and DOS with source hashes, focused overlays and separate compile/runtime outcomes; retain skipped, stale and missing evidence as such. - documentation/platform examples: expand Linux, FreeBSD and Haiku library qualification notes, add DOS emulator/library coverage and platform-comparison instructions, and document DXE multithreaded-runtime, packet-driver and unavailable-SDK limits separately from compile/link results. - examples/source maintenance: parenthesize expression macros, clarify intentional token-splicing and Unicode punctuation, wrap long SDL3 declarations, normalize legacy line endings and trailing whitespace, and add focused file ownership and platform notes while preserving the existing example style. - build/versioning: identify compiler and package outputs as 1.20.5 with package revision 1, refresh compiler objects when version metadata changes, and retain diagnostic compatibility with 1.20.4 and 1.20.5 producers. - compiler floating-point optimization: preserve parsed addition, subtraction and multiplication grouping in precise mode, including compound assignments and constant accumulation; retain reassociation in fast mode and add rounding and overflow regressions. - compiler semantic transport: make the self-describing FBCSEMB1 binary format the default for schema-27 models, with portable framed records, canonical integer tokens, a bounded string dictionary and structured property tuples; add shared public codec and generated element headers, and retain the same logical facts through -semantic-model-text diagnostic output. - compiler build verification: select the graph-reporting target explicitly so semantic transport dependency rules cannot become the graph probe's default target; track the shared wire headers in all compiler variants and include them in frozen source audits. - compiler semantic selections: retain the selected procedure and context for source NEW/DELETE applications and UDT FOR/STEP/NEXT operators, with physical token observations for custom allocation and iteration; distinguish object and type receivers for field references, and preserve the selected source method independently of a virtual call's dispatch signature; validate complete occurrence counts and freeze the new reader dependencies. - compiler semantic limits: align model-wide symbol identities and AST-node capacity with the consumer's 4,718,592-identity limit, retain finite byte and detail-row ceilings for large roots, preserve unsigned 32-bit datatype flags on 32-bit hosts, and check the producer, native reader and documented limits together. - compiler/GAS64: materialize integer immediates before floating conversion, preserve variadic floating argument delivery and use returned UDT sizes and bit-correct tail shifts for aggregate stores; add native C ABI and integer FRAC regressions. - compiler graphics and literals: retain the LOAD wrapper for descriptor-based image destinations and initialize nondecimal literal recovery state; cover nonzero array bounds and wide radix boundaries with focused regressions. - compiler AST: initialize failed helper results explicitly, guard null relational-node probes, keep local tree-count helpers available for -eassert builds, reject unsupported AST macro operators before backend emission, and preserve Unicode scalar values and effectful indices through SWAP compatibility checks. - bindings/POSIX CRT: add native FreeBSD and Haiku time and select headers, preserve their time and descriptor-mask widths, bound Haiku FD_SET/FD_CLR/FD_ISSET accesses, and expose iconv on FreeBSD and Haiku with Haiku's libiconv symbol aliases. - example runners: add bounded audio and image checks, deterministic display handling and native wx-c value comparisons; retain repeatable source dependency patches and update the SDL and legacy-library workflows. - compiler/runtime serialization: add opt-in Serialize and Deserialize helpers for supported values, UDTs and arrays, using a portable logical wire schema, bounded traversal and allocation, deep ownership and transactional destination replacement; add golden-wire, allocation-failure, malformed-input, cross-width and existing-behavior regressions plus manual references and examples. - compiler semantic model: preserve pointer-distance execution links, original constant storage bits and side-effect-safe power inputs; retain named function-result assignments and bind selected custom NEW/DELETE operators before lowering consumes their calls. - compiler diagnostics and preprocessing: retain parser-owned FOR, STEP and NEXT source locations, preserve EOF diagnostic source context, and add -pp-lines to retain mapped locations through includes, continuations, macro expansion and explicit line remapping. - compiler Windows imports: use the target's x86/x64 import-address-table spelling for DLL data, and add native cross-language import read/write tests; retain unsigned constant-operation bits and reject negative shift counts before width checks. - library bindings and examples: repair native widths, target layouts, calling conventions and DLL data declarations across legacy libraries; update graphics, compression, image, database, math, regex, network, sound and GUI examples with bounded inputs and owned-resource cleanup, and refresh their manual references and target-specific availability notes. - library qualification tooling: add repeatable Windows and Linux ABI, compile/link and runtime checks, focused dependency patches, controlled console/image helpers and compiler lint entry points; update SDL add-on building and Exampleageddon selection without installing or replacing shared toolchains. - bindings/SDL: add SDL3 core and companion bindings, organize SDL1/SDL2/SDL3 examples, and provide pinned SDK build, install, ABI and example checks with Windows libraries and their licenses. - compiler/GAS64: protect live division operands while selecting scratch registers, correct 32-bit register spelling and negative SINGLE stack immediates, retain queued stack argument values, and keep both four-byte stores in eight-byte fixed-string fills from losing their shared destination address; add division, stack-argument and guarded fixed-string regressions. - compiler semantic declarations: retain original type, enum, variable, procedure and member spellings with physical or macro origins and complete coverage receipts; observe accepted line-comment markers without copying comment bodies or interpreting naming policy. - compiler semantic inputs: retain original function results, explicit routine exits, OPTION routes, array dimensions, individual string tokens and lexemes, scalar FOR entry decisions, preprocessing identifier lookups and macro token offsets; preserve logical, comparison and string operand storage, numeric string-format inputs and written unary prefixes before lowering. - compiler semantic literals: retain bounded original floating-point input observations before constant conversion, including significant digit and exponent information, without changing ordinary numeric token consumption. - compiler semantic construction: retain inferred declaration ownership and original temporary constructions before elision, preserve selected macro-generated constructor calls with noneditable invocation anchors, and record INCLUDE ONCE protection on the actual entered source occurrence. - compiler semantic varargs and diagnostics: expose backend-independent Cva_Start/Cva_Copy/Cva_Arg/Cva_End operations and their operands, and report parser-owned unclosed procedures, rejected ON ERROR RESUME NEXT syntax and declaration suffix/AS conflicts without changing ordinary diagnostics or emission. - compiler semantic verification: include all new reader dependencies in frozen audits, qualify declaration and comment coverage with repaired-count corruption controls, test entered include occurrences and full/compact emission parity, and compare macro-constructor filenames using the native compiler's spelling under MSYS. - compiler semantic tests: exclude only the four-byte COFF build timestamp from native link-observer object comparisons; validate the object format and prove that every other byte still detects changes, preserving code, relocation, symbol, diagnostic and callback checks. - compiler semantic tests: preserve a stable backend filename during native Windows link-observer comparisons, preventing Clang's temporary C filename from changing COFF bytes while retaining exact object, diagnostic and linker-callback checks on ARM64 and x86 targets. - compiler semantic reader: convert native Windows paths through the MSYS/Cygwin mount table before resolving source revisions and edit plans; preserve exported filenames, source hashes, byte limits and stale-source rejection, and exercise native sidecar filenames in the existing edit-planning regression. - compiler semantic model: retain parser-selected named and anonymous namespace openings, including qualified, reopened and macro-generated forms; record each USING statement's actual recipient namespace under a separate capability so models with earlier header-policy counts remain readable. - compiler semantic model: retain accepted per-source pragma-once, library-directive and namespace-import policies in full models, with occurrence counts, escaped library values, conditional context and macro origins; independently validate complete receipts and freeze the new reader dependency for self/corpus audits. - compiler/Windows Clang: query the selected MinGW GCC toolchain for x86/x64 startup objects, system libraries and binutils, preventing an x64 Clang installation from selecting x64 CRT files while linking x86 code; retain Clang runtime discovery for Windows ARM64 and other platforms. - packaging/Windows fbc-js: update the verified official Binaryen overlay to version 133 to match Emscripten and retain warning-free package qualification. - compiler semantic expressions: retain typed written array-field prefixes in compact expression models for consumers such as the VS Code plugin, while reserving array symbol and receiver relationships for full models. - compiler semantic model: retain a noneditable macro-invocation anchor for generated include outcomes while omitting replacement-token directive spans, so clients can distinguish macro includes from command-line preincludes without changing include processing. - compiler semantic model: retain explicit calling-convention and managed-STRING header choices before prototype reuse, including aliases and pointer forms; pair each ABI-policy receipt with its accepted source header and validate its original occurrence. - compiler semantic tests: select each backend's actual emission suffix when comparing full and compact modes, freeze every new reader dependency for standalone self/corpus audits, and select explicit targets for assembly and calling-convention fixtures on ARM and non-Windows hosts; exercise each Windows CI row's native runtime and configured object tools, retaining additional installed SDK targets and explicit GNU ld versus LLD callback coverage. - compiler semantic model: retain the original typed formal and default initializer before an equal callback or repeated prototype reuses a canonical signature, so source assignment receipts remain complete after the unused header is freed. - compiler semantic model: export procedure and static-address assignment-storage offsets as leaf atoms, retaining their symbol and byte offset without treating the executable AST's preserved optimization child as a second value computation. - compiler semantic model: bind written UDT and typedef names in constructor expressions, record rejected QB intrinsic definitions without fabricated macro identities, and omit nonphysical include directive ranges while retaining full-model macro invocation anchors as noneditable origins and written logical-remap receipts. - bindings/Windows CRT: use the Universal CRT standard-stream accessor on all 64-bit Windows targets so `stdin`, `stdout`, `stderr`, and `OPEN ERR` link with the supported UCRT toolchain; retain the legacy stream table for 32-bit Windows compatibility. - compiler semantic tooling: validate physical attachments against source origins and statement/module ownership, require phase-owned native CFG targets, and check declared counts without count-sized allocations; preserve mapped lines after unrelated legacy bytes, share coordinate decoding across repeated revisions, retain unmatched recovery points without editable spans, and require complete models for edit planning. - compiler semantic model: retain original formal passing modes, written BYVAL/BYREF choices and optional-default expression identities before prototype reuse, callback interning or initializer lowering, including constructor-based UDT defaults; keep selected parameter contracts and generated receivers separate from written source facts. - compiler semantic model: format integer fields directly without the temporary leading-space trim used by `STR`, reducing CPU and allocations for multi-million-record exports while preserving byte-identical output. - compiler semantic tooling: add `-semantic-bundle <prefix>` to publish a reusable full model and structured diagnostics pair without duplicating compiler work; retain the existing transactional formats and source-hash validation boundary. - compiler semantic sidecar: initialize unnamed formal source state, guard temporary-address inspection against recovered dereferences with no value child, clarify source-coordinate code, and retain procedure visibility corruption checks alongside same-module ownership validation. - compiler semantic tooling: add bounded ASCII sidecar ingestion, a per-validation source revision cache, one-pass coordinate validation, a non-writing exact-LOC edit planner, and `validate-compiler-semantic-model.py` with text/JSON status; freeze the reader's complete module dependencies in self/corpus audits, and document suppression, project policy and report rendering as consumer responsibilities. - compiler semantic configuration: retain committed OPTION occurrences, actual BASE operands and independent statement-opening token locations, including repeated directives; snapshot whether REM remains an installed keyword after OPTION NOKEYWORD and reset that policy with each module. - compiler semantic literals: retain parsed numeric kind, radix, canonical token text, completeness and consumed alphabetic suffixes with source/configuration contexts and macro origins; distinguish literal observations from folded values, exponent letters, hexadecimal digits and discarded preprocessing text. - compiler semantic expressions: retain original explicit-cast and compound-assignment inputs, compiler-selected numeric operand types and values before folding, and numeric destination types before assignment conversion; keep original operands distinct from noneditable converted observations and preserve Boolean's normalized value contract. - compiler semantic queries: retain LEN/SIZEOF input types, nominal subtypes and original expression or array identities, mark complete TYPEOF/SIZEOF unevaluated parser intervals, and preserve query and expression predecessor links through folding without claiming that those inputs execute. - compiler semantic storage: retain built-in @/VarPtr/StrPtr inputs and temporary-storage observations, pointer dereference depth, original pointer-index inputs including write targets, and parsed NEW/DELETE families with selected element counts, clearing and placement operands; do not infer allocation success, aliasing or lifetime guarantees. - compiler semantic arrays: retain selected fixed/dynamic array and field identities, rank-sized original and converted subscript groups before descriptor/offset lowering, and LBOUND/UBOUND occurrences with original and selected dimensions before constant folding; validate complete same-statement groups independently of result values. - compiler semantic loops: retain original WHILE/DO/LOOP conditions, explicit unconditional forms, scalar and enum FOR bounds and STEP inputs, STEP source sites, and compiler-selected converted step types/constants; distinguish omitted steps from dynamic expressions and pointer/UDT iteration contracts. - compiler semantic SELECT CASE: retain original selectors, selected storage, ordered CASE value/range/IS alternatives, ELSE membership and completion counts before comparison or jump-table lowering; validate accepted statement ownership and bound the ordinary CASE table before indexing. - compiler semantic strings: retain original CHR/WCHR/UCHR and TRIM/LTRIM/RTRIM arguments and ANY selection through folding, plus fixed-character initializer targets and element capacities; export actual static/runtime copy contracts, retaining ambiguous or unselected lowering without assuming terminator or padding behavior. - compiler semantic calls: link accepted call arguments to their original caller expressions before formal conversion and optimization, retaining selected formal and call ownership while excluding omitted/default arguments; add bounded linked-argument validation and cross-target emission/corruption tests. - compiler semantic file transfers: retain GET/PUT kind, scalar/whole-array selection and original typed storage before BYREF AS ANY or descriptor lowering; connect observations to selected runtime calls without treating character transfers as descriptor copies or unevaluated inputs as executed I/O. - compiler semantic declarations: retain accepted prototype statement identities and occurrence-specific EXTERN, TYPE-alias and legacy prototype repetitions, distinguishing exact repetition from array-shape refinement; preserve canonical procedure/formal replacements and physical or macro occurrence origins without changing declaration acceptance. - compiler semantic callbacks: retain each anonymous FUNCTION/SUB convention choice even when its type is interned, plus original named-header LIB/ALIAS choices and callback counts; reflect disabled fastcall/thiscall options and validate nested callback ownership without changing ABI selection. - compiler semantic assignments: attach exact named source destinations to original initializer, ordinary-assignment and compound-update expressions, including fields and procedure parameter variables; keep selected source formals separate from generated storage and exclude pointer dereferences and property setters. - compiler semantic object names: export observed/unobserved cached GAS/GAS64 procedure object symbols without invoking the mangler; mark C/LLVM object-name coverage unavailable in the AST model instead of treating compiler identifiers as linker evidence. - compiler semantic diagnostics: add independent transactional `-semantic-diagnostics <file>` FBCDIA output for accepted and rejected invocations, with source/module closure, warnings, errors, physical diagnostic points, native outcomes and bounded strict readers; retain typed LINE INPUT and NEXT contexts without requiring a recovered AST. - compiler semantic diagnostics: classify native procedure-signature conflicts and rejected case-different variable bindings with per-module coverage, original declaration points and bounded live-symbol tracking; keep exact duplicates, legal overloads, shadowing and repaired invalid headers from becoming false conflict proofs. - compiler semantic linking: add independent `-semantic-link-diagnostics <file>` FBCLNK output with verified source revisions, accepted procedures, native-access flags, backend-selected object names, original link arguments and actual tool outcomes; observe GNU ld undefined-symbol/missing-library callbacks through an invocation-owned checked journal, preserve caller helpers, and report unavailable coverage without inferring successful resolution. - compiler semantic provenance: anchor generated typed expressions to actual macro invocations while retaining distinct parser operations, operator sites and original expansion ancestry; compact full exports keep a bounded internal invocation map without advertising an exported macro graph or editable replacement bytes. - compiler semantic resources: cache up to 8 MiB of source line offsets for revisited coordinates, raise the bounded per-module staging limit to 512 MiB for large GUI roots, and report the first export failure with resource totals; add focused target/encoding, capability, corruption and unchanged-emission checks for the new observation families. - gfxlib2/Haiku input: bridge native press/repeat/release, special and modifier keys, mouse transitions, both wheel axes, focus and close events to ScreenEvent and legacy polling; correct Enter/editing scancodes, preserve pressed characters on release, release held input on focus loss, and synchronize bounded state without reversing window/driver lock order. - gfxlib2/Haiku windows: add native resizable software modes, checked replacement bitmaps and coalesced resize requests, preserve fixed-size windows, and use borderless desktop-sized fullscreen presentation; add single-threaded/multithreaded input, 8/16/32-bit resize and repeated-mode smokes to the Haiku VM runner. - gfxlib2/Haiku rendering: compare marked 32-bit rows against the presented bitmap, copy only changed spans and coalesce scaled damage through view invalidation; retain shared palette/16-bit conversion, validate pitches and replicated rows, preserve dirty state on failed updates, and remove per-query scheduling yields. - gfxlib2/DOS: add opt-in `DOS_GFX_LOW_POWER=YesPlease` timer selection and a bounded foreground `fb_GfxDosIdle` wait driven by PIT ticks, preserving the default 1 kHz profile and BIOS timing; rebuild only affected graphics objects when the profile changes, and document host qualification and cursor pixel tests. - gfxlib3/shadow buffers: track per-page horizontal and vertical CPU damage, upload only the selected rectangle with its original row pitch for 8/16/32-bit storage, and retain full-row fallbacks for unbounded writes; add display-independent damage, page-isolation and copy regressions. - rtlib/x86: accelerate memory comparison by skipping equal complete four-byte words, then comparing the first differing word and short tail bytewise; retain unsigned first-byte ordering and exact span bounds, with alignment, zero-length and Windows guard-page regression coverage. - compiler semantic model: preserve scalar dynamic String declaration defaults and original initializer identities before descriptor lowering; distinguish DIM/STATIC storage, instance fields and inferred/reference/array storage, validate complete associations in both readers, and preserve GAS/GAS64/GCC output. - compiler semantic model: export complete ordered visibility sections and their actual aggregate-body owners after macro expansion and conditional selection; validate unique counts and same-body statements in both readers, retain compact exclusions, and preserve ordinary GAS/GAS64/GCC emission. - compiler semantic model: retain original named procedure result-type and written visibility choices before prototype reuse and scope defaults; validate complete accepted headers in both readers, preserve compact exclusions, and keep full/compact/off and old/new code emission byte-identical on GAS, GAS64 and GCC. - compiler semantic verification: validate written procedure visibility receipts against their accepted statement and module, retain strict metadata domain checks, and reject dangling or cross-module owners. - compiler semantic model: keep compiler-converted array indices nonphysical while retaining the written index type and range, anchor implicit bound dimensions to the intrinsic token, and preserve dereferenced pointer-index result types without letting the index claim the full expression range. - compiler semantic model: retain parser-owned declaration groups, explicit and implicit type choices, original formal typing and selected scalar initializer classes; preserve code generation and compact exclusions, validate complete groups in both readers, and keep one-field record initialization distinct from scalar values. - compiler semantic model: export selected target wide-literal prefixes for GAS and GAS64 alongside GCC, retain actual backend byte differences, and bound the shared assembly escape buffer for supplementary UTF-16 output; preserve emitted code and compact exclusions, with both readers checking complete groups and selected target unit limits. - gfxlib2/DOS: coalesce refresh requests deferred by SCREENLOCK instead of draining historical callbacks before the next draw; preserve BIOS and idle clocks and add nested-lock cursor publication checks for both timer profiles. - compiler/USTRING: added a built-in dynamic UTF-8 string type with Unicode scalar lengths, slicing, search, comparison, zero-based indexed reads and writes, UCHR construction, byte/wide/numeric conversions, and the existing descriptor ownership rules for parameters, results, arrays, and UDT fields; preserve macro shadowing, expose __FB_HAS_USTRING__, and provide FB_NO_USTRING for existing user-defined types while retaining QB's original keyword set. - rtlib/Unicode: added validated UTF-8 decoding with maximal-subpart replacement, supplementary-scalar conversion to UTF-16 and UTF-32, embedded-NUL preservation, Unicode 17.0 full casing with expansions and final sigma, scalar-aware trimming, repetition, alignment, and replacement, and direct UTF-8/UTF-16/UTF-32 encoded file I/O; check in the generated case tables and their regeneration tool. - compiler/rtlib text APIs: route STRING, WSTRING, and USTRING through printing, PRINT USING, input, DATA reads, file transfers, pathnames, environment variables, process commands, date/time functions, dynamic-library names, and graphics/sound text arguments with explicit conversions and temporary cleanup; add compile-time coverage for all three text types and runtime conversion checks. - bindings/string and file helpers: added mixed byte, wide, and UTF-8 overloads for StrComp, Replace, StrReverse, and Format, wide pathname overloads for FileCopy, FileLen, FileExists, FileDateTime, GetAttr, and SetAttr, and WSTRING/USTRING LEFTSELF helpers; Unicode pathname conversion uses UTF-8 independently of the process locale, and existing byte interfaces retain their ABI. - gfxlib2/text: added UTF-8 DRAW STRING and wide/UTF-8 DrawStringSize routing that advances once per Unicode scalar, preserves UTF-16 surrogate pairs, and uses the bitmap font's fallback glyph for unsupported characters; add headless measurement and pixel-equivalence regressions. - bindings/RISC OS: add WSTRING and USTRING overloads to the length-prefixed UTF-8 fbnetwire helpers, retain complete Unicode scalars at byte limits, and require explicit destination capacity for wide reads while preserving the existing wire format and target double layout. - compiler semantic model: schemas 10 through 17 add exact compiler-selected default, initializer, NEW, argument, and return constructors plus declared-local, temporary, scope-exit, and DELETE destructors; retain overload signatures and verified owner ranges through argument resolution, IIF/WITH temporary lifetimes, and GOTO/RETURN/EXIT/CONTINUE cleanup without presenting generated calls as editable callee tokens. - compiler semantic model: schema 19 adds completed symbol snapshots, visibility/storage/origin, canonical replacements, procedure and parameter signatures, fixed/runtime array bounds, UDT/enum/scope layouts, exact constant values, initializer and inheritance relationships, AST payloads and jump tables, virtual-call static targets, and per-module target/primitive-type metadata; full output now retains the same completed expression prefixes as compact output. - compiler semantic model: extend the stable operator vocabulary with member access, math functions, conversions, length, and iterator operations, retain resolved operation records through folding and lowering, and export macro parameters, replacement tokens, and undefined-definition history; schema 20 makes the wire format byte-safe with single-pass percent escaping for controls, non-ASCII bytes, legacy source text, literals, and paths. - compiler semantic verification: added an independent strict sidecar reader, corruption and failure-path tests, dedicated contract fixtures, OMA corpus checks, and a compiler-source audit driven by the frozen Make source graph; compare full/compact facts, dependency closure, physical UTF-16 ranges, and byte-identical emission with export disabled, full, and compact across GCC, Clang, and LLVM. - compiler semantic model: export parser-owned written OVERRIDE presence and absence after macro expansion, independently of resolved base-method identity; align the producer and independent reader with schema 27, validate phase/flow ownership, and keep declaration initializers outside procedure-body flow without changing code generation or existing language behavior. - compiler semantic model: add optional schema-27 capability, kind and complete-location receipts for individual formal parameters while preserving declaration-name ranges; cover unnamed and variadic declarations, nested callback signatures, descriptors and defaults, and distinguish generated formals without fabricating editable ranges or implicit-receiver locations. - compiler semantic model: preserve compiler-selected macro-generated field/procedure uses and source-requested constructions through optional schema-27 reference-origin and implicit-call coordinate receipts; retain existing I columns and LOC output, distinguish generated ranges from physical invocation anchors, and verify nested/repeated uses, selected overloads, encoded sources and logical remaps without changing ordinary code generation. - compiler semantic model: export optional schema-27 procedure-linkage K/CAP receipts from the accepted symbol's declaration mangling, independently of calling convention or aliases; preserve foreign prototypes whose bodies are defined outside EXTERN, expose normalized BASIC/C/Windows/C++/Pascal/rtlib values, and verify full versus compact availability on GCC, GAS64 and LLVM without changing signatures, runtime ABI or ordinary code generation. - compiler semantic model: add optional schema-27 finalized source-field counts, complete native field order and explicit scalar/array-rank properties, using real aggregate ownership while excluding inherited/static members and hidden compiler storage; validate nested/anonymous groups and older models independently, and preserve byte-identical ordinary output across full, compact and disabled exports. - compiler semantic access: observe FOR initialization as a source write and add optional schema-27 direct-source-write zero/one receipts for actual variable destinations before runtime lowering; retain generated names and implicit string-parameter storage without inventing physical bindings or inferring pointer/field/unknown-callee effects, and verify native write forms, module reset, old clients and unchanged GCC/GAS64/LLVM emission without grammar or ABI changes. - compiler semantic model: add optional schema-27 per-statement FOR counter identity and local/existing observations from the accepted parser symbol, retaining repeated uses, physical counter tokens and actual macro origins; emit counter locations after statement completion for streaming readers and verify scopes, native rejection behavior, old clients and byte-identical GCC/GAS64/LLVM output without changing grammar or lowering. - documentation/semantic tooling: added compiler restructuring and semantic verification reports, a source inventory, AST/symbol class and layout-field coverage matrices, and a detailed gap catalog with reproduction and acceptance cases; document remaining source-context, lowering, analysis, and platform coverage limits with evidence for facts and failure paths the current schema does not cover. - compiler/structure: reorganized the compiler into focused driver, core, lexer, preprocessor, parser, symbols, AST, runtime, backend, platform, support, and tooling directories; split the driver into option, file, tool, compilation, link, help, and platform modules, document source ownership with headers and footers, and separate public semantic observation hooks from private exporter state. - compiler/build: added one canonical source graph for native, variant, and bootstrap builds with duplicate-basename rejection and structural checks for includes and private-header boundaries; replace duplicated DOS AST/parser/driver and RISC OS helper implementations with narrow host floating-point policies selected independently of the compilation target. - compiler/LLVM: replace repeated output-string concatenation with reusable geometrically grown section buffers and checked size arithmetic, including separately staged procedure allocations, while releasing owned storage after emission. - compiler/LLVM builtins: enable builtin.bi with -gen llvm and lower libc-compatible calls, bit counting, byte swaps, overflow arithmetic, object-size queries, branch hints, prefetch, trap, and unreachable operations to libc or LLVM intrinsics; validate declarations, operand counts, constant hints, and probability ranges, preserve overflow-result stores, and reject addresses of intrinsic-only operations. - compiler/preprocessor: make wide macro quoting and unquoting use retained argument lengths, checked final-size calculation, and one final replacement buffer, avoiding repeated wcslen searches and suffix reconstruction while preserving aliased input and escaped text. - gfxlib3/Linux: added a native DRM/KMS, GBM, EGL, and OpenGL ES 3 display path for systems without a desktop, with runtime-loaded libraries, page-flip presentation, display-state restoration, evdev keyboard/gamepad input, and explicit platform selection; prefer GLES on DRM and OpenGL before Vulkan on the desktop, while keeping the adapter optional when development headers are unavailable. - gfxlib3/GLES: batch opaque filled and eligible outline ellipses, size their span buffers from actual work, and use native indexed, 16-bit, and 32-bit integer texture formats with direct or row-wise uploads instead of expanding every source pixel to RGBA; share the renderer between Android and Linux through a typed dynamic GLES dispatch table. - gfxlib3/memory: apply byte-based backpressure to queued commands as well as slot limits, reject oversized atomic batches while allowing one valid large upload into an empty queue, and reduce retained image snapshot budgets on DRM handheld displays; add queue-budget and screen-depth regression coverage. - sfxlib/MIDI: expose sfxlib.MidiPlaying() in sfxlib_raw.bi so applications can detect completion of asynchronous MIDI file playback and restart background tracks. - compiler/build/Amiga: added the classic AmigaOS 3.x m68k target and bootstrap layout, GCC-driven Hunk linking, target CRT headers, and a shared 68020 software-floating-point ABI; provide a pinned SDK build workflow, checked startup-object repairs, and a CPU soft-float helper archive for compiler/runtime/graphics/sound builds. - rtlib/Amiga: added native startup, console and filesystem services, directory enumeration and attributes, command execution, serial/printer support, timer queries, and pthread integration; use a checked Exec-backed allocator before SDK heap constructors and arbitrate thread exit versus detach to avoid stale pthread handles, while keeping TCP, command-backed OPEN PIPE, clock setters, and named-symbol DylibLoad explicitly unavailable in the initial port. - gfxlib2/Amiga: added native Intuition graphics using CyberGraphX RTG screens or private chipset screens, dirty-row conversion, private palette ownership, keyboard-layout translation, and mouse/focus/wheel handling; retain deterministic missing-device results for unsupported joystick queries. - sfxlib/Amiga: added AHI output with Paula audio.device fallback, chip-memory stereo DMA buffers, PAL/NTSC resampling, and a background mixer worker with coordinated device shutdown; use native delay services where the SDK lacks nanosleep. - build/tests/Amiga: added FS-UAE fbctests and Exampleageddon runners with frozen compiler/library inputs, disposable boot volumes, retained resources, native return-code collection, bounded hangs, and preserved reports, plus graphics and sound smoke examples; classify those examples as platform-specific on other targets. - bindings/libopenmpt: added the C API header, Win32/Win64 import libraries and runtime manifests, Debian binding-package inclusion, and checked in-memory module examples that produce stereo WAVE files or raw PCM without PortAudio. - build/tests/compiler: added permanent source-structure, host arithmetic, storage, backend ABI, builtin, inline assembly, and test-harness checks to quick/full workflows, plus USTRING language/rejection/example tests and Linux address/undefined-behavior sanitizer sweeps over Unicode scalars, casing tables, malformed input, aliasing, allocation limits, and descriptor ownership. - packaging: advance the compiler build revision and Debian package to 1.20.4-3, including the batched ARM64 GLES rendering improvements for the R36+ handheld. - compiler/lexer: bound byte and wide string token writes during quote and escape handling, preserve closing quotes in truncated retained text, and add QB-mode regressions for both source encodings. - compiler semantic model: add the opt-in `-semantic-model` sidecar with transactional module output, globally stable symbol references, resolved variable type facts, procedure records, typed AST nodes, source locations, and schema/count validation; use compiler type facts in FBL503 without changing ordinary compilation, and document schema version 2. - compiler semantic model: schema version 8 adds stable conceptual operator codes and `builtin`/`overloaded`/`none` kinds to AST and expression records, deriving overloaded operations from the compiler-selected procedure while retaining raw AST numbers as diagnostic detail. - compiler semantic model: schema version 9 preserves parser-known conceptual operator codes when AST construction normalizes built-in operators or lowers them to helper calls, keeping compiler-private AST numbers out of the tooling ABI. - compiler semantic model: export references for `@` and `ProcPtr` procedure-address expressions after compiler overload resolution, preserving the selected procedure identity for project-wide tooling. - compiler/preprocessor: expose accepted source #cmdline options through __CMDLINE__ and reflect verbose, effective architecture, custom entry, export, PIC, calling-convention, variadic-argument, return-register, abstract-type optimization, builtin, and preprocessor settings through intrinsic defines; suppress the replay warning for a directive that enabled -z nocmdline, and add regression coverage for ordered options, quoted values, restart persistence, and source/code-generation settings. - linter/style: FBL009 skips a line that follows an explicit continuation. Its alignment is horizontal layout within an open statement and no longer produces a false mixed-indentation result. - examples/TinyPTC and linter/style: normalize the remaining legacy block layouts without changing drawing, clipping, or copy behavior, completing a warning-free automatic-width style pass across all 1,722 examples. - compiler/AST: replace an obsolete null-pointer-check TODO with the implemented direct-address and pointer-indexing optimization boundary, without changing generated code. - documentation: added a 1.20.4 release guide and documentation index, audited all 804 commits after 1.10.0, recorded the complete 1.10-to-1.20 release history and the untagged 1.20.2 development baseline, updated the introductory platform and requirements pages, added references for previously undocumented public headers, FLTK, MariaDB, the Xbox -title option, and target/CPU defines, added current package-repository and Termux installation notes, a NuttX workflow guide, a portable fbcom.bi reference, gfxlib3 selection, compiler-option, and intrinsic-define pages, and the complete SCREEN 1 through 13 compatibility-mode table; repaired all external-library index targets and two malformed email links, and rebuilt the manual formats with the current release version. - build/CI: added an independent Cppcheck job that derives its manifest from every tracked first-party C and C++ source file, currently 1,479 files, excludes only an explicit set of vendored and generated compiler-output sources, and fails on new warning, performance, or portability diagnostics. - build/CI Linux packages: derive the full package build matrix from the canonical package-factory plan, covering all 73 current Debian/Ubuntu/Raspbian, Alpine/postmarketOS, RPM, Arch Linux, and Slackware rows; create that matrix from the exact master revision after the FreeBASIC XL CI qualification has passed fbctests and Exampleageddon, and retain release-tag, explicit-dispatch, and weekly scheduled paths. - build/CI Linux packages: allow wildcard row selection before jobs are scheduled and configurable numeric concurrency for manual package runs; qualify Fedora Rawhide, Tumbleweed ARM64, Slackware, and Arch ARMv7 rows early while retaining the complete canonical matrix. - build/CI Linux ARM64: run supported ARM64 distribution package builds on native hosted ARM64 runners with matching host bootstrap sources; keep Arch's ARM64 cross-build container on an x86_64 runner to match its userspace. - build/CI RISC OS and AROS: retain Exampleageddon resource trees through emulator staging while discarding them for compile-only runs; print bounded RISC OS reports and failing guest logs when qualification fails. - build/CI BSD and Haiku: make every QEMU qualification explicitly verify the native `.pkg`, `.tgz`, or `.hpkg` produced and installed by the guest scripts, and retain each installable package as a 30-day artifact on push, pull-request, scheduled, manual, and release runs instead of exposing dedicated package artifacts only for version tags. - build/tools: hardened the gfxlib2 font and palette generator, DOS DXE export-table generator, and Win32/Windows CE fbportio generator and tester with bounded argument handling, validated file sizes and reads, checked allocations, and explicit owned-buffer cleanup. - build/release: run the qualified FreeBSD, OpenBSD, NetBSD, DragonFlyBSD, and Haiku x86_64 VM package builders as part of tagged GitHub releases, publish their native package formats with the main asset set, and allow those guest packages to be rebuilt and attached independently to an existing release. - build/release: stop treating the Linux MIPS cross-compiler archives as complete platform packages or publishing them with tagged releases; MIPS compiler and runtime qualification remains in the test workflows. - gfxlib3/files: added an independent copy of the dependency-free PNG codec for BLOAD, BSAVE, screen pages, and direct GPU asset loading, including checked chunks and CRCs, DEFLATE streams, scanline filters, indexed/RGB/RGBA images, alpha, Adam7 input, case-insensitive `.png` selection, GPU ordering boundaries, documentation, and exact CPU/GPU round-trip tests. - gfxlib2/SIMD: added SSE2 acceleration on x86_64 and NEON/Advanced SIMD acceleration on ARMv7 and AArch64 for logical, transparent, alpha, blend, additive, preset, and alpha-mask pixel operations; ARMv7 checks AT_HWCAP before selecting its isolated NEON object, ARMv6 remains scalar, the existing 32-bit x86 MMX fallback is retained, and an offscreen checksum benchmark isolates CPU compositing from display presentation. - sfxlib/SIMD: added exact PCM buffer conversion kernels for 32-bit x86 MMX/SSE and SSE2, x86_64 SSE2, ARMv7 NEON, and AArch64 Advanced SIMD; optional instruction sets are isolated in separately flagged objects and selected only after CPUID or AT_HWCAP checks, while pre-CPUID x86, incomplete MMX/SSE feature sets, ARMv6, and unsupported ARM systems retain scalar conversion with the existing NaN, clipping, and x87 evaluation behavior. - sfxlib/mixer: changed ordinary voice rendering, software FM, echo, diagnostics, and ring-buffer transfers to operate in blocks; added SSE2/NEON waveform generation, sample accumulation, and final clamping with runtime-safe dispatch; replaced per-sample sine calls with an interpolated table; and added a null-driver benchmark plus a scalar reference switch for measuring each optimized workload. - rtlib/Win32: separated desktop Windows filesystem and wide-integer compatibility implementations into the Win32 platform layer, with one shared runtime check selecting Windows 95/98/ME behavior while Windows NT systems retain their existing Unicode paths. - rtlib/gfxlib2/gfxlib3: added optional byte-string comparison, replacement and reversal helpers, independent pathname attribute queries and changes, native bitmap-font measurement, and packed two-color border fills without adding compiler keywords or changing the historical QB and FreeBASIC dialects. - packaging/Windows 95: produced a standalone FreeBASIC 1.20.4 package containing the current compiler, headers, examples, normal and multithreaded rtlib, gfxlib2, and sfxlib archives, Win95-compatible GNU binutils 2.19.1 tools, the required tool CRT, MSVCRT40 import libraries, compatibility notes, a native smoke test, retained test evidence, and SHA-256 manifests. - build/tests/Windows 95: qualified FreeBASIC inside an actual Windows 95 OSR2 guest at an i486 baseline; native `fbc.exe` successfully compiled, assembled, linked, and ran a console/file-I/O smoke test, all 37 fbctest executables passed, and all 651 unattended Exampleageddon cases passed with no failures, timeouts, or invalid results. - compiler/build/DOS: added the experimental `dos-hx` target alias for 32-bit Win32 PE programs intended for the HX DOS extender, the opt-in `-dos-threads pdmlwp` native DOS thread provider, provider-specific runtime/archive layout and installation, optional Watt-32 TCP and DPMI host-yield configuration, synchronization-safe copy-before-remove package staging, and matching compiler-print, make-structure, fbcprint, manual, and package-staging coverage while preserving the default single-threaded, TCP-disabled DOS profile. - rtlib/sfxlib/DOS: added the maintained PDMLWP provider sources and DOS runtime integration for RTC preemption, per-thread TLS, thread lifecycle, recursive mutexes, queued condition variables, heap/DPMI/DOS-call serialization, and safe ISR stack state; the optional x87-only profile disables incompatible SIMD tiers, supports worker-fed Sound Blaster and PC speaker playback, MIDI workers, scheduler-aware delays, and fallback to foreground audio when initialization cannot complete. - rtlib/DOS TCP: added an explicit Watt-32 IPv4 provider for OPEN TCP and OPEN TCP SERVER, including lazy packet-driver initialization, bounded nonblocking buffering, timeout and readiness handling, complete sends, clock setup, normal FreeBASIC error reporting when the packet driver is absent, and protection for Watt-32's exception handlers and shared socket state. - sfxlib/DOS AC'97: added bounded Intel ICH AC'97 PCI/codec discovery and 48 kHz signed 16-bit stereo DMA playback with safe conventional-memory descriptors, Sound Blaster-first selection, codec and PCI state restoration, DMA-stop quarantine on failed shutdown, and ordinary or PDMLWP-backed playback without claiming shared PCI interrupts. - bindings: made public leaf headers directly includable by adding narrow prerequisites and breaking declaration cycles across CUnit, FLTK, IUP, CD, many libxml/libxslt leaves, VLC, JSON-C, Chipmunk, Flite, GDSL, MySQL, wx-c, libart, Fontconfig, Freeglut, and related runtime headers; expanded Windows leaf validation to 265/265 for native x64 and Win32, and repaired GDI+, D3DX9, RPC, DDK, SDK-version, COM, OpenGL, and variadic C declarations without changing the umbrella include paths. - build/exampleageddon and examples: added multi-file companion mappings, source-local `-entry`, QB, GTK3, and gas64 rules, cleanup with `--keep-work` forensic retention, source-built helper archives, the VB string-helper smoke example, and fixes for DOS PRINT USING, SDL/OpenGL constness and string lifetimes, OpenGL BGR formats, and the Win32 VARIANT `NOTHING` collision. - tests/documentation: added DOS provider probes for PDMLWP, Sound Blaster, PC speaker, AC'97, Watt-32, graphics, TCP, FreeDOS and DOSBox-X runs, enabled matching optional DOS unit/log suites, added `#cmdline`, gas64 array-index, and sfx intrinsic regression cases, and documented the compatibility services, direct-include results, DOS provider boundaries, AC'97 behavior, and SuperDuel integration findings. [fixed] - rtlib/file locking: correct one-based inclusive LOCK/UNLOCK byte and RANDOM-record ranges, including single positions, with file-number and overflow checks; use nonblocking POSIX locks with the correct read-only mode, preserve full 64-bit Windows offsets and lengths, and report unavailable locking on Windows CE and NuttX instead of success; add cross-process contention and exact-unlock regressions. - rtlib/Amiga file metadata: align automatic FileInfoBlock query buffers to the DOS-required four-byte boundary while preserving their native layout; cover word-aligned stack callers and guarded native queries across file, directory, copy and filesystem operations. - gfxlib3/Vulkan selection: reject adapters without shaderFloat64 during probing so ordinary backend selection can continue to OpenGL before mode creation, avoiding a later renderer failure on the first exact midpoint ellipse. - gfxlib3/Vulkan lines: rasterize only the bounded visible run when a compatibility line exceeds the packed shader's 32,767-step limit, preserving original nearest-pixel rounding, 16-bit style phase and submission order; cover long horizontal/diagonal and fully clipped lines alongside ordinary short lines. - build/Windows CE graphics: restore the native backend under drivers/wince after the source restructure and require its selection in graphics source-graph checks. - build/archive portability: feed archive members through bounded xargs batches instead of GNU-only response-file arguments, supporting Apple's archiver and Windows command limits while retaining indexed, atomic archive publication. - build/CI contracts: isolate Make fixtures from inherited toolchain and recursive-Make overrides, give missing-toolchain checks a deterministic host, and install the ZIP tool required by native qualification and Windows packaging. - tests/services: evaluate state-changing callback and idle-step operations before checking their results, preserving those side effects when assertions are disabled. - build/CI Haiku: retry interrupted guest file transfers up to three times and retain early VM diagnostics on failure, while preserving transfer errors and leaving guest commands and qualification gates mandatory. - packaging/Debian examples: update the Vera font links for the SDL1 and SDL2 directories so both samples use the installed Bitstream font package and pass strict font validation. - build/CI RISC OS: fetch and authenticate the three pinned emulator/system archives before building the toolchain, cache only these download inputs, and revalidate restored bytes so later build or test failures do not force repeated vendor downloads. - tests/floating-point grouping: compare literal and variable operand paths using each backend's native intermediate precision, and exercise both SSE and x87 significand boundaries with cancellation so precise-mode regrouping regressions remain observable without requiring binary64 rounding after every operation. - bindings/libffi Darwin: retain Apple's 24-byte x86_64 and 12-byte i386 trampolines while preserving newer x86 layouts elsewhere; compare the binding's native ABI against the selected SDK's C headers before running guarded call and closure checks in macOS CI. - build/CI Windows: allow 120 minutes for x86/x86_64 native qualification and 150 minutes for ARM64 so the full semantic suite, language and example checks, and job cleanup can finish. - build/RISC OS: retry bounded archive downloads after connection resets, identify the requested archive in CI logs, and retain pinned SHA-256 checks and temporary-file cleanup before caching emulator and system inputs. - build/Slackware packages: select IPv4 explicitly for package-manager downloads in the IPv4-only Docker matrix, preserving native download policy and package checksum/signature validation. - packaging/Debian: assign the shared semantic codec, generated element table, serialization and service/drop/idle/notification/randomness headers to the core package, and SDL3 headers to the bindings package; retain exact single-package ownership for every installed include. - compiler/GAS64 debug information: make ELF debug-address records writable for loader relocations while keeping debug strings read-only, allowing OpenBSD PIE links without changing the platform's PIE policy. - build/guest examples: pass a new extensionless output filename to the file serialization example in RISC OS and AROS startup scripts, and verify the generated guest commands alongside resource manifests. - compiler semantic smoke tests: request diagnostic text explicitly for record checks, accept counted comment observations, and independently validate identical default-binary and text facts before running the existing semantic assertions. - compiler/GAS64 BSD: select the SysV argument, stack and call-preservation ABI on NetBSD, OpenBSD and DragonFly instead of the Windows register convention; retain each target's existing aggregate-return policy and exercise the division and ninth-SINGLE-argument regressions. - compiler semantic tests: freeze the complete non-field-member and macro-call reader dependencies, and require one consistent virtual-table/RTTI target across repeated symbol snapshots rather than one serialized relationship row. - build/exampleageddon CI: name cross-built Windows CE products with their target suffix, publish relative retained-resource directories for RISC OS/AROS/Windows CE staging, and add quick-test coverage for guest manifests and zero-exit missing products. - build/CI diagnostics: remove accidental generated example C output from version control and ignore its exact paths while retaining whole-tree C lint; print bounded failed log-test details before preserving the failing result. - compiler/Amiga: preserve cross-built object and archive dependencies in Hunk metadata, read native concatenated-unit libraries as well as ar containers, and bound big-endian section, symbol and relocation traversal; qualify transitive library and direct-object links without adding dependency flags to callers. - compiler driver: stop after rejecting an assembly syntax for an unsupported CPU or native backend, preserving a failing exit status and preventing object output after the diagnostic. - gfxlib2/BMP: repeat narrow bitfield components across the destination width, fixing one-, two- and three-bit colour/alpha expansion and avoiding negative shifts; verify mixed native Amiga colours, live palette changes and 1,024 image samples without changing corpus programs. - gfxlib2/Amiga: choose the nearest available chipset palette levels for true-colour framebuffers using precomputed component tables; verify all 256 component values at 8, 16 and 32 bits and preserve live indexed palette changes. - gfxlib2/Amiga: bound oversized display requests to the selected monitor's available ordinary modes while preserving the virtual canvas and nominal aspect; avoid a 320x128 fallback when the ROM provides a suitable 1280x512 display. - gfxlib2/Amiga: honor SETMOUSE pointer visibility through Intuition's native sprite selection, retain transparent chip-memory data until the window closes, and check hide/show transitions across framebuffer depths. - rtlib/Amiga: inherit the creator's native input/output streams in FreeBASIC threads and restore provider-owned streams before process cleanup, preserving redirected worker output without closing parent handles. - rtlib/Amiga: read redirected LINE INPUT through the stream reader instead of the interactive carriage-return editor, avoiding hangs on LF-terminated input files. - rtlib/Amiga: let BASIC global destructors signal and join their workers before runtime task cleanup; retain the final task wait before releasing runtime state and unloading Hunk segments. - rtlib/Amiga: close sound and graphics contexts reopened by BASIC global destructors before the final task wait, avoiding an idle audio worker keeping the command alive. - build/Amiga floating point: retain double-product guard/sticky bits, clear transferred single-product bits, classify infinity times NaN correctly, and preserve signed underflow; compare 20,000 native multiplications with a hardware oracle and check signed-zero division. - rtlib/Amiga: provide the missing PC port-I/O fallbacks with the documented runtime errors instead of unresolved link symbols, select the native C stream declarations in SDL2 bindings, and include the long-integer prerequisite when the CRT time header is used independently. - compiler semantic output: handle temporary-directory name collisions through the runtime's file query instead of assuming host errno values, preserving atomic reservations when DOS or concurrent exports choose the same clock-based name. - sfxlib/Linux: reject overflowing frame/channel products, report only samples accepted by ALSA or PulseAudio, advance diagnostic offsets after short ALSA writes, and bound zero-progress retry handling; keep failed submissions out of the diagnostic stream. - compiler/build/DOS: use the 8.3-safe libfblwp.a provider name consistently in driver links, runtime archives, installation and probes; derive DXE import-library names from the module basename rather than its output directory. - build/DOS Watt-32: propagate the selected provider library flags to compiler and bootstrap links, retain the duplicate-strerror link policy, and locate the DJGPP payload archive explicitly when preparing DOS builds. - build/DOS packaging: add the underscore-prefixed profiling section bounds required by DJGPP COFF, validate repeated linker-script patches, and use the mounted-directory DOSBox-X smoke path on MSYS2 where disk-image host paths are unreliable. - compiler/bootstrap: clear and collect emitted sources from the checked response file so split compiler source paths are retained correctly, reject malformed response entries, and leave maintained C support files outside generated-output cleanup. - bindings/Android CRT: give public mode_t its Bionic 16-bit width on ARM/x86 LP32, use that alias for creat/creat64 arguments, and retain the existing internal Linux __mode_t layout. - examples/DOS: select the complete DXE filename and underscore-prefixed dynamic symbol, link the matching import archive, use the optional OPEN TCP device for HTTP examples with bounded response waits, correct embedded-data aliases, and fix frame-regulation timer rollover checks. - examples/GUI: pass canonical C boolean values and the actual Double width to GooCanvas variadic properties, retain C-int formatting widths, and report IUP initialization failures before constructing dialogs. - examples/OpenAL: check buffer/source creation and playback operations, release each acquired resource on failure and normal exit, and add bounded unattended playback without changing the interactive pause/resume controls. - examples/PortAudio: validate default device and owning host-API information, close active streams before callback payloads leave scope, release initialized library state on device and playback failures, and return errors from final shutdown. - examples/native ABI: use StdCall for Win32 multimedia timer functions and pointer-sized integer conversions in allocation/thread demonstrations; give the RANDOM-file example an explicit record length matching its transferred value. - compiler/GOSUB: mark computed assembly targets with the same landing-pad contract as direct GOSUB, check out-of-range ON GOSUB selectors before saving a return frame, and implement GAS64 saved-address pushes and RETURN-label stack release; retain the setjmp route and add direct/computed, nested and invalid-return regressions. - compiler/calling conventions: avoid dereferencing a missing head parameter for zero-argument fastcall/thiscall procedures and callback types; add an empty-parameter regression. - compiler/LLVM: emit the valid x86_thiscallcc/x86_fastcallcc convention names on declarations and calls, and omit calling-convention syntax from procedure-pointer type definitions while retaining it at indirect calls. - compiler/preprocessor output: exclude detached speculative parser probes from -pp token emission and preserve alphabetic numeric suffixes so preprocessed literals retain their selected types when reparsed. - compiler/LLVM ARM: pass llc the selected Linux ARM architecture and gnueabi/gnueabihf target triple, sharing the floating-point ABI decision with dynamic-linker selection; lower probability-bearing branch hints to ordinary llvm.expect on 32-bit ARM, dropping only the unsupported optimization probability. - compiler semantic flow: retain actual procedure exit labels and conditional transfers at the right-child tail of lowered AST sequences, including string-comparison cleanup; validate phase/root-label membership and evaluation order without presenting internal expression transfers as a complete CFG. - compiler semantic control: classify accepted GOTO, direct/computed GOSUB, GOSUB RETURN, procedure RETURN and ON ERROR set/clear dispatches in full and compact exports, retaining actual statement and bound-label ownership rather than inferring behavior from keyword spelling. - gfxlib2/Haiku lifecycle: synchronously join native windows before freeing bitmaps, destroy owned BApplication instances between modes and on startup failure, and initialize unused kernel IDs to negative values; keep SCREENINFO tied to the desktop and return defined unsupported console GETMOUSE outputs instead of recursing into itself. - gfxlib2/DOS cursor: erase previously published cursor rows without restoring stale foreground pixels, redraw the cursor when banked damage or palette changes require it, and skip unchanged framebuffer publication while continuing input polling; cover movement, hiding and nested SCREENLOCK publication in pixel tests. - gfxlib3/input: recognize button-only evdev gamepads and combined keyboard/gamepad devices under DRM, and normalize Win32 XInput Y before GETXPAD's screen-to-stick conversion; add native-width output guard coverage for absent controllers. - gfxlib3/build tests: avoid X11 headers and runtime probes when X11 support is disabled, use the native platform selector instead of private vtable symbols in infrastructure tests, and remove duplicate Win32 runtime input stubs. - bindings/sfxlib: give the wide OutputCaptureSave helper its C calling convention and assign its function result without RETURN, keeping sfxlib_raw.bi usable by legacy OPTION GOSUB callers. - compiler semantic model: retain selected array-bound dimensions and their source ranges, mark omitted dimensions and incomplete pointer-intrinsic prefixes as nonphysical, and preserve typed array assignment targets in expression-only output without changing emitted code. - compiler semantic array bounds: keep folded query results distinct from identical omitted dimensions under logical source remaps and macro expansion, preserving input order and the reader's cycle checks. - build/CI compiler structure: give the structured-diagnostics header the required responsibility marker so native compiler qualification reaches its smoke and language tests. - CRT/platform coverage: add Haiku, BSD/Solaris, AROS, and classic Amiga unistd bindings, select Android and RISC OS headers explicitly, and map Windows CE process identity to its native API instead of a missing getpid export; preserve native process/file-offset widths and AROS native-sized IDs, and compile standard CRT headers for every supported OS during backend checks. - CRT/Windows CE: provide a runtime C bridge for CeGCC's inline-only GetCurrentProcessId accessor so the portable getpid binding links on ARM and MIPS without assuming a Coredll export or copying kernel-data addresses into BASIC headers. - compiler semantic SELECT CASE: preserve selected comparison operand types, text routes, branch disposition and AS CONST converted bounds/table bias; validate complete bounded groups in both readers, and keep distinct generated operand identities when casts have identical visible shapes. - tests/semantic sidecar: accept the compiler's explicit array-bound dimension-presence receipt, retain the selected dimension when the source argument is omitted, and reject contradictory flags while preserving older explicit-input records. - tests/semantic CI: validate protected macro-invocation ranges in the integration smoke check and compare formal-parameter byte offsets against unchanged source bytes on CRLF checkouts. - tests/Haiku graphics: make window-mode progress tracing opt-in so successful resize/fullscreen qualification keeps stderr empty while retaining every native geometry and lifetime check. - compiler/bootstrap and structure: avoid reserved BASE and NAME identifiers in the semantic type exporter so older bootstrap compilers can build it; recognize the exact generated-C prelude with either LF or native Windows CRLF while still requiring its owning BASIC source. - compiler semantic verification: complete the schema-27 reader and smoke checks for normalized types, procedure AST phases, evaluation order, conservative control flow, and diagnostics, including record ownership and completion totals; correctly chain auxiliary AST children and keep symbol/default initializer metadata outside procedure-body phases. - compiler/constant folding and wide literals: preserve all 64 bits of unsigned MOD intermediates on 32-bit compiler hosts, and reserve both UTF-16 surrogate code units for supplementary WCHR literals even when the compiler itself runs on a UTF-16 host. - compiler/C toolchains: apply Clang's libc builtin names, aliases, prototype rules, and Intel inline-assembly adjustments when the GCC backend invokes the Clang-based Darwin or Windows ARM64 system compiler. - compiler/LLVM and Windows assembly: select LLVM's aarch64 backend by its correct name, pass explicit x86 word-size options to C compilers, and use matching Windows target triples and native Clang/LLVM object emission, including direct Win64 COFF output, instead of feeding incompatible unwind directives to GNU as; add ARM64 assembly and Windows COFF machine-type checks. - compiler/Windows ARM64: select LLD and the platform's compiler-rt and libunwind libraries for every source backend instead of limiting them to -gen clang. - bindings/errno: use the native errno accessors on FreeBSD, DragonFlyBSD, NetBSD, OpenBSD, and AROS instead of global errno declarations, and define Darwin's EEXIST with its target error number. - bindings/file helpers: declare FileFlush and FileSetEof with the runtime calling convention, including stdcall on Win32, while preserving the QB-compatible declarations. - rtlib/file metadata: query Windows CE and Xbox paths and streams through their native APIs instead of unavailable POSIX stat/fileno interfaces, preserve Xbox path conversion and drive search, support directories and read-only files, and report identity only when supplied by the platform; pass typed FILE pointers to other libc fileno implementations. - rtlib/Amiga and sfxlib/RISC OS: make the descriptor-table bound explicit before releasing Amiga file handles, and keep output-capture loop declarations compatible with the RISC OS C compiler. - build/tests native hosts: select Intel syntax for the Darwin x86 assembly fixtures, keep all C++ test stages on the libc++ deployment floor of macOS 10.7 or the requested later target, and resolve the available host LLVM tool; preserve fixture-local includes from temporary build directories, print failed backend commands, enable ASSERT in host-policy probes and allow DOUBLE rounding in x87 text-time comparisons. - build/CI diagnostics: retain nested language-test logs in failure artifacts across Linux, Windows, Darwin, and Windows ARM64 jobs instead of collecting only top-level failed-*.log files. - build/RPM repositories: handle Fedora Rawhide's development repositories and DNF5 repository locations without assuming stable-release files exist; use the official openSUSE origin for Tumbleweed ARM64 dependencies while retaining repository signatures and package digests. - build/Slackware architectures: use matching multiarch images in package builds and native qualification, build ARMv7 for 15.0 and ARM64 for current, and select package architecture, mirrors, and slackpkg trees from container userspace rather than the host kernel; verify the installed GCC target triplet before building. - build/Slackware dependencies: exclude testing toolchains from stable 15.0 dependency selection, refresh current's libc before package tools and installed libraries, add required ACL/attribute libraries, and handle slackpkg's no-change and self-upgrade statuses without hiding installation failures. - build/Arch Linux ARMv7: replace the unavailable x86-host hard-float cross-toolchain path with a signed upstream ARMv7 root filesystem, verify its expected signing key, initialize its package keyring, and build with native ARM dependencies under QEMU. - build/CI Linux package artifacts: require a nonempty package in the row's native format, fail unavailable Slackware image builds instead of reporting a successful skip, and upload package files separately from diagnostic logs. - packaging/Debian: include the Amiga bindings, string-unicode.bi, and Unicode license in the core package; add quick/full checks that every installed include file has exactly one core or bindings package manifest entry. - build/release recovery: publish Slackware .txz and Arch .pkg.tar.* packages with the other release assets, and allow BSD/Haiku artifacts to be recovered from a separate completed workflow run. - compiler/storage: centralize checked count, size, alignment, growth, and terminator arithmetic for node pools, arenas, stacks, size-class allocation, hashes, and compiler byte/wide buffers; make zero/one-item pools grow, preserve aligned payloads and old allocations on failed growth, and reject overflowing or invalid allocation requests before use. - rtlib/string descriptors: identify temporary descriptors with checked integer-address ranges and pool-entry alignment before locating their owner, avoiding undefined comparisons or pointer arithmetic between unrelated STRING/USTRING objects. - compiler/runtime arguments: propagate failed string-descriptor argument conversions before dereferencing the rewritten AST, turning incompatible runtime-helper redeclarations into normal diagnostics instead of compiler null-pointer crashes. - compiler/QB preprocessor: return recursive macro-evaluation errors to the outer parser after an inner lexer context is popped, preventing error recovery from hanging on byte and wide source fixtures. - compiler/C and Clang: give typed C aliases distinct internal declarations while retaining the requested external symbol, resolve addressable libc builtins through their real C names, correct Intel inline-assembly memory operands and Clang's 64-bit byte-swap prototype policy, and disable costly generated-C uninitialized warnings after -Wall while allowing later user flags to re-enable them. - compiler/LLVM ABI and assembly: pass large System V x86-64 C aggregates through correctly aligned BYVAL copies, retain va_list array decay, and share the same parameter policy across declarations, calls, and body storage; emit consecutive inline assembly together with memory/register clobbers and stack-frame/red-zone protection, with default and optimized C ABI regression checks. - compiler/LLVM emission: keep shadowed and sibling local names distinct, preserve nested static aggregate and array initializer boundaries, emit correct union storage/alignment and procedure addresses, and keep null-pointer checks valid in SSA control flow; use decoded literal lengths and explicit padding so wide and terminated static strings cannot emit uninitialized buffer contents. - compiler/GAS64 portability: make stack-copy alignment use the cursor's fixed 64-bit type even in 32-bit compiler builds, and reject signed overflow before adding padding; add emission checks for Win32, Linux MIPS32, and RISC OS host configurations. - compiler semantic identities: reset ordinary and preliminary procedure-header identities on pool reuse, retain canonical signature/parameter replacements when callback types are interned, preserve lexical scope ownership and formal-to-body relationships, and correct STRING descriptor sizes plus explicit THIS parameters in method-derived procedure-pointer types. - compiler semantic AST: read branch targets only from AST classes that initialize their extra operand, avoid querying scalar alignment for the internal XMMWORD type, retain virtual calls' compiler-selected static method, and keep LLVM procedure/label addresses out of variable-storage queries. - compiler semantic output: stage models beside their destination, protect source/include and compiler-output paths using canonical names and file identities, reject aliases and special destinations, and check write/flush/close/replacement failures before publication; preserve an existing model on failed compilation and remove staging files on handled failures. - gfxlib2/Linux fbdev: avoid redundant mode changes that invalidate framebuffer mappings, read back accepted geometry, add a write-backed framebuffer path for Rockchip DRM with an explicit access-method override, enter console graphics mode before touching display memory, and stop/join the renderer before releasing mappings, input state, and synchronization objects. - gfxlib2/Linux controllers: use joydev axis and button maps for sticks, triggers, D-pad, and handheld-specific button codes, accept successful map ioctls that return a copied size, and throttle absent-device reopen attempts while retaining hot-plug detection. - gfxlib2/gfxlib3 pixel coherence: refresh gfxlib2 pixel transfer routines when alpha-primitives mode changes, preserve dirty CPU pixels before alpha-blended CLS, update locked shadows with the blended result, and upload indexed SCREENPTR shadows at the same synchronization boundary as true-color pages; add alpha-clear and screen-depth regressions. - bindings/QB and runtime ABI: keep EXTERN blocks and OVERLOAD syntax out of QB's string.bi and file.bi branches, retain explicit C aliases and target runtime calling conventions for new overloads, and cover byte-interface linking plus Linux/Windows x86/x86_64 semantic declarations. - rtlib/Unicode I/O and printing: skip an empty final encoded-write flush, register Unicode LPRINT USING with the printer callback, and keep printer initialization in its own archive member so ordinary PRINT USING does not pull in platform printer libraries; add a link-only printer probe that runs without opening a device. - build/bootstrap and cleanup: remove incompatible regular runtime objects before a minimal bootstrap, preserve maintained compiler C support while cleaning or collecting only emissions corresponding to BASIC sources, and include that support in bootstrap output; serialize aggregate clean/bootstrap workflows and isolate each compiler smoke target's temporary files under parallel make. - build/tests harness: select the newly built native compiler after prerequisites run, forward the chosen backend through language and recursive multi-module tests, bound individual compiler/program hangs when GNU timeout is available, require exactly one result record per expected log, and return failure for failed or incomplete results; update semantic smoke validation for the extended schemas and record totals. - build/CI portability: give Haiku's awk-backed grep correct per-file and stdin counts, empty-file output, option precedence, and error statuses, with a configurable GNU awk for hosts whose default awk lacks the required extensions; remove locale-dependent numeric dates from text regressions, validate casing-buffer bounds, and narrowly annotate the inspected Amiga pointer conversions for Cppcheck. - build/CI RISC OS: print the Exampleageddon report, failing self-contained cases, and relevant compiler or guest batch logs in the Actions job when qualification fails. - build/CI AROS: retain Exampleageddon resource trees for full emulation runs so staging can copy each example's resources after compilation. - build/Windows CE: let the compile-only Exampleageddon qualification finish after its gated compile inventory instead of creating an emulator manifest from deliberately discarded resource trees; retain those trees only when the emulator execution path needs them. - build/RISC OS: replace the no-longer-resolvable default GCCSDK Subversion checkout with its reachable Git mirror while retaining the established toolchain layout, update behavior, and explicit legacy Subversion-revision support. - examples/build hygiene: remove emitted NeHe lesson 21/24 assembler and BASSMOD C output from version control, ignore their regenerated forms, and keep clean checkouts free of stale compilation artifacts. - build/Windows CE: make Exampleageddon inspect compiler options embedded in `--fbc` before selecting gas64, preserving the ARM GCC generator instead of appending an incompatible x86-64 backend; classify gas64-only examples as platform-specific when their required backend is unavailable, so they are reported rather than treated as ARM self-contained failures. - build/CI diagnostics: retain Cppcheck output and the RISC OS toolchain-build log as seven-day failure artifacts, so version-specific lint and guest-build errors remain available after a failed run. - rtlib/TCP: keep the Watt-32 listener's indefinite-select policy outside the TCP select macro call, preserving the zero-timeout behavior while allowing Cppcheck 2.13 to preprocess the source. - build/Exampleageddon: classify AROS-only smoke fixtures as platform-specific outside AROS so Windows CE and other target inventories report them without treating their unavailable native services as portable failures. - build/CI: print bounded Exampleageddon and RISC OS failure evidence in the action log, including the affected self-contained source and compiler or guest-run output when available. - build/Exampleageddon: classify the complete shared-library manual fixture set as helper modules, preserving its compile inventory while avoiding standalone-program qualification for sources that require the documented `-dll` or companion-library build rules. - compiler/GAS: reuse each module's recorded stage-one assembly path only for GAS/GAS64 assembly, so invocation-private object filenames are not given the temporary tag a second time while GCC, Clang, and LLVM retain their required second-stage assembly input; repair the Windows x86 compiler smoke build and the Linux self-hosted compiler build after the parallel-build isolation work. - compiler/parallel builds: make compiler-owned object files, backend intermediates, response files, and static-library metadata private to each compiler process; keep the required `__fb_ct.inf` archive member name and preserve the historical object names exposed by `-c`, `-C`, retained assembly modes, and explicit `-o`; add a concurrent executable/archive regression smoke test. - compiler/FB_NO_SFXLIB: mark every sfxlib intrinsic procedure at registration so disabling sfxlib consistently releases SFX-only names for declarations and preprocessor definitions, including NOTE; preserve active non-sfx symbols such as the system BEEP, report the sfxlib-specific redefinition diagnostic with FB_NO_SFXLIB guidance for variables, constants, procedures, preprocessor definitions, and command-line definitions, and cover the complete intrinsic set plus MUSIC, SFX, MIDI, DEVICE, and CAPTURE. - compiler/FB_NO_GFXLIB: mark every gfxlib intrinsic procedure at registration so disabling gfxlib consistently releases identifier-style names such as SCREENRES, BLOAD, and FLIP in addition to gfxlib keywords; report the gfxlib-specific redefinition diagnostic with FB_NO_GFXLIB guidance for declarations, preprocessor definitions, and command-line definitions, and add regression coverage for both enabled and disabled gfxlib cases. - build/repositories: allow unsigned CI-produced Alpine and postmarketOS packages while generating local APK indexes. - build/Termux Android: update the default Android target package to the qualified 1.20.4-1 Resolute artifact, verify its exact checksum, and reject an unexpected package version before extracting it. - packaging/Debian: advance Debian, Ubuntu, Raspbian, and Android packages to 1.20.4-1 and reject package builds whose Debian upstream version differs from mk/version.mk. - build/packages/Resolute: stage the pinned official devkitPPC toolchain, allow the Xbox package builder to create its own nxdk tree, and require NuttX, Wii, and Xbox Debian artifacts from the Ubuntu Resolute amd64 Actions row. - build/packages/Debian: validate foreign-architecture packages with native-host Lintian under a 30-minute deadline, use two emulated compiler workers for ARM64 and RISC-V, log package and validation phase times, and allow one named Linux package row to be dispatched for diagnosis. - build/Windows, Haiku, and RISC OS validation: restrict the Windows 95 CRT adapters and literal-folding policy to their intended Windows targets, avoid collisions with the current x86, x64, and ARM64 MinGW CRT, stage Haiku source trees with ZIP when current GNU tar cannot write BFS files, use explicit coverage-checked fbctests manifests plus linked-object and assertion-count guards, provide an awk-backed basic/extended expression scanner when GNU grep returns `EBADF` on populated BFS volumes, and preserve RISC OS runtime UTF-8 conversion semantics. - build/AROS packages: wrap PKG1 archives in the bzip2 stream required by the native Unpack command, verify the decompressed package tree, qualify installation and native compilation from clean x86_64 and m68k guests, verify ARM installation and direct compiler components while retaining the known nested-driver failure, let Unpack continue without its progress window on serial-only systems that have no public screen, avoid the ARM FAT handler's installed-directory and POSIX path-probe lockups, locate GCC support programs below SYS:Developer, run ARM GCC stages synchronously through SystemTags, and avoid flushing terminal escape sequences through redirected ARM FAT files. - build/NetBSD validation: serialize the fbctest object build inside NetBSD 11 guests, avoiding intermittent GNU make `readdir` EINVAL failures while retaining parallel package and Exampleageddon work. - build/AROS validation: allow seven minutes for each x86_64 fbctest VM batch, keeping the heavy expressions/fbc-int/file/functions batch within a bounded deadline when hosted-runner timing exceeds the former four-minute limit. - build/CI and rtlib/NuttX: support Ubuntu 24.04's Cppcheck 2.13 diagnostic identifiers, document the bounded lifetime of synchronous gfxlib3 test completions, and check wide-string scan limits before indexing input on NuttX. - compiler/platform backends: initialize unsupported constant-folded floating comparisons deterministically, retain Linux library-search results before inspecting them, and report failed AROS Hunk or RISC OS AIF final renames while leaving the converted output available for recovery. - gfxlib2/gfxlib3: reject overflowing image and framebuffer sizes, unwind initial and partial allocation failures including event-mutex state, make Windows CE dirty-buffer allocation overflow-safe, and initialize and validate dynamically loaded XRandR function pointers before use. - rtlib/string and file I/O: track temporary wide-file read-buffer ownership explicitly, handle failed or empty fractional formatting, bound Boyer-Moore table allocation and suffix indexing, and validate wide-string inputs and temporary allocations before conversion or concatenation. - rtlib/gfxlib2/gfxlib3: prevent aliased Unix file copies from truncating their source, route Windows copies through the existing pathname conversion, validate custom bitmap-font geometry consistently, make gfxlib2 PAINT allocation failures leave pixels unchanged, and restore indexed gfxlib3 screen GET through the coherent work-page shadow. - rtlib/platform backends: bounds-check JavaScript keyboard state and use the correct wide-output argument type; correct NuttX generic file-mode selection and temporary-string helper ABI; validate Solaris console allocations and terminal sequence indices; return a neutral Wii thread result; and handle Xbox conversion allocations and format-string literals safely. - compiler/Windows 95: fold known narrow string literals directly to target WSTRING literals instead of asking the guest CRT to interpret them through a locale, preserving string, WSTRING, Boolean-file, and IIF behavior on Windows 95 while leaving dynamic conversions unchanged. - rtlib/Windows 95 filesystem: use one Windows-family check to select ANSI file open, reopen, status, removal, directory mutation, and directory enumeration APIs on Windows 95, 98, and ME while retaining the existing UTF-8-to-Unicode paths on NT-family systems. - rtlib/Windows 95 CRT: replace MinGW-only 64-bit integer string helpers with checked bounded formatting, provide wide 64-bit formatting without the optional `_i64tow` family, and bridge `__iob_func`, `__acrt_iob_func`, `_stat32`, and `_wstat32` to the equivalent MSVCRT40 facilities for both normal and multithreaded runtimes. - sfxlib/Windows 95: resolve CoInitializeEx at runtime and fall back to CoInitialize, preventing linked WASAPI support from making WinMM programs fail to load on stock Windows 95 systems without the optional DCOM update. - tests/Win32: use command syntax shared by COMMAND.COM and CMD.EXE in the pipe test, allowing the C runtime to select the correct interpreter for each Windows family. - examples/manual: make the module IMPORT example valid C by replacing its Basic-style comments with a C file header and footer. - examples/OpenGL: validate NeHe lesson 24 and 32 TGA dimensions and payload length before allocating, and release the temporary pixel buffer after OpenGL uploads it. - examples/OpenGL: make NeHe lesson 25 reject unavailable, malformed, truncated, oversized, or unallocatable object data before drawing; seed its generated model; and correct its Z-coordinate motion. - bindings: make CACA, FLTK, GMP, libiconv, MySQL, and SDL2 callback parameters explicitly CDECL where their C APIs require it, without changing compiler-native callback types. - bindings: remove trailing whitespace and one mixed indent from 323 public headers, leaving declarations and external ABI layouts unchanged. - examples/manual CDECL: declare `strcpy`'s source argument as a const string pointer, matching the C input contract while retaining its mutable destination. - examples/NuttX: make `fbhello_smoke.bas` obtain one checked `FreeFile` handle and validate every `Open` through `Err` before using it, report the failed operation, terminate the smoke instead of emitting invalid follow-on results, and reject an unexpectedly empty `ReDim` result before bounds or element access. - tooling/fblint: make `FBL-DOC-BIN-003` associate a binary `Open` with the matching later raw `Put #` or `Get #` handle, report one format-contract warning at the first transfer, and omit lock-only handles plus `OPEN COM` and `OPEN PIPE` live streams; add regression coverage for repeated raw transfers and the lock-only boundary. - tooling/fblint: make `FBL-STR-009` require both a fixed-length `String` UDT field and later raw Binary or Random file transfer before reporting a file-layout policy issue, preserving real serialized-record warnings while omitting external ABI and in-memory records; add raw-record and memory-only regression coverage. - examples/NuttX: document the five intentional `Input #` and `Write #` smoke checks with narrow `FB-LINTER: DISABLE-NEXT-LINE FBL517` annotations, retaining the rule for unreviewed formatted file operations. - examples/NuttX: make the `fbhello_smoke.bas` RAM-fixture paths, same-build binary transfers, fixed random-record layout, and checked working-directory removals explicit; all destructive relative directory operations now validate their literal target and report a failed removal immediately. - tooling/fblint: keep the broad `FBL103` output-write reminder in lighter profiles but omit it in strict mode where `FBL-IO-005` provides the specific diagnostic; recognize immediate `Err` checks following `Rmdir` as valid filesystem error handling. - tooling/fblint: recognize an immediate `Err` comparison after an output or append `Open` in lighter profiles, retaining `FBL103` for unchecked writes and adding checked and unchecked regression fixtures. - tooling/fblint: recognize combined `NEXT inner, outer` terminators as closing contiguous nested `FOR` frames in style analysis, accepting established outer- and inner-aligned forms; normalize the manual nested-loop lesson without replacing its combined terminator. - tooling/fblint: validate each counter in a combined `NEXT` from inner to outer and close the matching number of tracked loops, retaining `FBL-LOOP-005` for a mismatched counter; remove the no-longer-needed manual suppression and add valid and invalid regression fixtures. - tooling/fblint and examples/manual: add an explicit `--indent-width auto` style policy that infers each file's smallest stable non-tab indentation width while retaining the default four-space policy for one-space or conflicting layouts; infer from logical statement starts so continuation alignment cannot select a false width, summarize repeated `FBL015` width violations per file with their first location and count, skip byte-oriented layout checks only for NUL-containing encoded source while retaining semantic analysis, add three-space and mixed-layout regression fixtures, normalize the four genuinely mixed manual examples, and retain zero manual style findings under the automatic policy. - examples/NuttX: give the `fbfilecopy_smoke.bas` source and destination fixed `/ram` paths, checked `FreeFile` ownership, checked `FileCopy` status, and conditional known-fixture cleanup on every failure path. - examples/NuttX: give `fbsd_smoke.bas` a checked `FreeFile` owner, immediate open checks, a fixed SD-card fixture contract, and conditional cleanup after both failed and successful readback. - examples/NuttX: make the combined device smoke document its Screen 13 DVI-lab requirement, restore text mode after every later failure, and use checked mass-storage fixture ownership and cleanup. - examples/NuttX: document the fblite GOSUB/RETURN runtime smoke and the exact Screen 13 DVI/QEMU contracts for the graphics smokes; retain bounded demo key polling and restore text mode before graphics failure exits. - examples/PCRE: give `preg_t` checked vector and nested match-array allocation, preserve the existing match table until reallocation succeeds, release partial failures, and clear every released nested owner and result count. - examples/OpenGL: restore the MilkShape 1.3/1.4 loader's 14-byte packed header on 64-bit hosts; bound every parsed record, validate model indices, check allocations and file reads, and make partial-load cleanup idempotent. - examples/OpenGL: harden the NeHe BMP loader with validated 8/24-bit BI_RGB headers, dimensions, offsets, palettes, padded row reads, and full failure cleanup while preserving RGB texture output. - examples/OpenGL: make the NeHe picking demo's mouse-button release test explicitly Boolean, document its shared state and intentional atlas cell arithmetic, and state fixed selection and viewport bounds. - examples/CACA: document the metaball renderer's single-threaded shared buffers, separate its animated state declarations, and make the original rounded integer palette quantization explicit without changing the generated palette values. - examples/TinyPTC: distinguish the fblite sprite demo's generic target-array parameters from its shared display and sprite arrays, and add section markers plus consistent local indentation without changing its drawing calls. - examples/TinyPTC: state the flower tunnel's zero-based shared-table bounds, distinguish its supplied target tables from module state, and reject empty or mismatched coordinate arrays before traversal. - examples/TinyPTC: state the blob lightmap's zero-based bounds, reject an empty lightmap before compositor bounds access, distinguish supplied target arrays from module state, and document the intentional standalone error termination. - examples/Win32 COM: make the text drop target validate its output pointer, use the Windows field-wise GUID comparison, preserve null failure output, and avoid using or unlocking a failed `GlobalLock` result while always releasing a successful `GetData` medium. - examples/Win32 TreeView: document the GUI-thread shared-state and synchronous string-buffer boundaries, use `SizeOf` for the raw insertion structure, split local declarations, normalize continuation indentation, and rely on normal module termination after the message loop. - examples/Allegro: give the starfield and model fixed arrays explicit zero-based bounds, document its two single-threaded shared-state groups, distinguish the local face pointer from its type, and reject an unavailable offscreen bitmap before rendering. - tooling/fblint: index initialized TYPE fields by their declarator instead of the initializer token, preserving implicit member references; recognize `@pointer->member` as pointee storage rather than a local-pointer return escape, with regression coverage for both boundaries. - bindings/Win32 VARIANT: normalize three declaration-indentation lines without changing its public overload or ABI surface. - tooling/fblint: keep numeric widening, integer-division, and signed/unsigned comparison checks out of `DECLARE` operator headers, with a declaration-only regression fixture. - tooling/fblint: recognize Allegro's documented `palette_color` external pointer, with a focused binding regression fixture. - examples/OpenGL: make the compact drawing helper use consistent continuation indentation and disable blending for an invalid blend-mode value, preserving a known OpenGL state. - tooling/fblint: recognize tab-aligned TYPE field declarations before locating their AS clause, keeping implicit member references visible to declaration checks with regression coverage. - examples/OpenGL: give the SDL quadrics sample explicit zero-based fixed and dynamic array bounds, traverse its generated texture through LBound and UBound, document its single-event-loop state ownership, and normalize its continuation indentation. - examples/OpenGL: make the NeHe bump-map lesson document GLFW-owned render state, use explicit vector and matrix bounds, and load logo alpha/colour BMP pairs through checked, size-bounded, dimension-matched storage with unified cleanup. - examples/OpenGL: document the NeHe grid game's single-loop shared state, make its array bounds explicit, guard the dynamic texture-transfer buffer before its address is used, and separate its integer glyph row from the floating texture scale. - examples/TinyPTC: document single-loop ownership in the lens demo, make its shared table bounds explicit, reject empty or mismatched coordinate arrays in its distance helper, avoid a framebuffer parameter shadow, and normalize its layout. - examples/Win32 Direct3D: replace inferred vertex-buffer byte counts with named counts and SizeOf(Vertex), correcting triangle-list overrun and triangle-strip under-upload boundaries; document idle render pacing and clear the external presentation structure with SizeOf. - examples/zlib: document buffer, stream, and error-unit ownership; pass the actual preset-dictionary length rather than pointer size on 64-bit targets; and close/clear main-owned resources after the complete native compression smoke sequence. - examples/OpenGL: name the NeHe masking lesson's display, viewport, and camera constants; set its five-texture arrays to exact zero-based bounds; make key-edge toggles explicitly Boolean; and normalize continuations. - examples/OpenGL: harden the NeHe Bezier lesson's bitmap, display-list, and point-array ownership; retain the last good display list when replacement generation fails; reject invalid division counts; and document the BLOAD Err boundary. - examples/OpenGL: make the NeHe world-walk lesson validate and own its parsed triangle array through normal cleanup, check its bitmap transfer before texture creation, and use explicit Boolean key-edge state. - examples/TinyPTC: seed and correctly advance the torus demo's independent rotation axes, document single-loop state, avoid framebuffer parameter shadows, and validate smoothing-array bounds before neighbour access. - examples/TinyPTC: give the Julia-rings demo's fixed tables explicit zero-based bounds, document its TinyPTC ownership, and initialize the per-pixel colour selector before use. - examples/OpenGL: make the standalone texture sample retain natural module termination after data declarations, check texture loading, and validate its zero-based transfer-array dimensions and BLOAD result before texture creation. - examples/OpenGL: document the NeHe particle lesson's SDL surface, palette, and particle ownership; seed its random particle state before use; and normalize its image-upload and gravity-update continuations. - examples/OpenGL: document the NeHe raw-image blitter's headerless RGB input and temporary-image ownership; validate allocation, raw-read, blend-rectangle, and texture-upload boundaries; and release temporary and OpenGL texture resources after both setup failures and normal termination. - examples/OpenGL: give the NeHe texture-filter and fog lesson checked zero-based bitmap storage, immediate BLOAD error handling, explicit key-release tests, and texture cleanup after normal or partial initialization. - examples/OpenGL: harden the NeHe display-list font lesson's two bitmap transfers and texture/list ownership, document its module-local shared state, and retain documented integer glyph-row selection. - examples/OpenGL: make the NeHe GLU quadric lesson validate bitmap storage and BLOAD, reject an unavailable quadric, release textures and the quadric across every initialized exit, and use explicit key-release tests. - examples/OpenGL: give the NeHe height-map lesson an exact zero-based raw-terrain array contract, checked open and transfer paths that return from the loader, documented module state, and an explicit render-toggle release test. - examples/OpenGL: document the NeHe texture-filter and blending lesson's module-local state, validate three-name texture creation and mipmap build, clean partial texture state, and use explicit keyboard-release tests. - examples/OpenGL: document the GLUT sample's callback lifecycle, give fixed light vectors explicit bounds, and use `Long` callback parameters that match GLUT's C `int` ABI. - examples/OpenGL: document the NeHe TGA font lesson's shared OpenGL state, reject unavailable texture or display-list names, clean initialized objects, and retain documented byte-header and glyph-row operations. - examples/OpenGL: make the NeHe radial-blur lesson validate CPU texture allocation and generated names, return initialization failure to module scope, guard blur passes and normal normalization, and document shared render state. - examples/SDL OpenGL: document SDL lifecycle ownership, request OpenGL attributes before SDL creates the video context, give light vectors explicit bounds, and normalize mixed indentation. - examples/arrays: give fixed arrays explicit bounds, guard dynamic-array bounds and parameter traversal against emptiness, retain the dynamic array through its last use, and document the fixed UDT-field boundary check. - examples/Win32 COM: document browser and COM ownership in the WebBrowser example, split initialized declarations, define the disabled toolbar edit command, avoid local browser-name shadows, and normalize continuations. - examples/GTK GooCanvas: express the grid's phi, pi, and middle-dot markup with ASCII XML numeric references and document GTK widget ownership, preserving rendered glyphs without source-encoding dependence. - examples/GTK3: document custom-widget GObject ownership, use an explicit fixed box half-width, and declare every GtkWidget and GObject virtual-method callback CDECL to match the GTK ABI. - examples/GTK: document the calculator's GTK-main-thread display state and its generated GladeToBac implementation boundary, retaining the executable-module include and exact-zero division rule with narrow strict-lint annotations. - examples/Win32 GUI: keep the file-open filter buffer alive through the synchronous dialog, store the window class name in fixed zstring storage, check window creation, document ownership, and normalize continuations. - examples/network: document all OPEN TCP handle ownership in the two-connection self-test, add five-second socket timeouts, preserve immediate TCP ACCEPT error reporting, and verify two distinct localhost replies. - examples/manual: retain the QB/FBlite DIM type-suffix teaching declarations with narrow, documented strict-lint exceptions beside each compatibility example. - examples/manual: retain the FBlite OPTION BASE ordering and implicit arrays that demonstrate its later-declaration effect, with narrow documented lint exceptions. - examples/manual: document GFX_NULL framebuffer and Win32 paint ownership, seed its animated rectangles, and retain a narrow documented module-startup termination for registration failure. - inc/crt: make the Win64 `setjmp` binding pass MinGW-w64's required optional frame argument while preserving the established one-argument call form and the non-C-backend null fallback. - examples/trycatch: document the deliberate signal-fault paths and process-local context, make Exception string replacement allocation-safe and leak-free, reject null exception inputs before dereference, and verify nested throws and signal catches on Win64. - tooling/fblint: recognize FreeBASIC's type-first `Dim Shared ByRef As T name` form in parser and project-index declaration tracking, with shared-declaration regression coverage. - examples/manual shared libraries: document caller-owned and DLL-owned shared-reference lifetimes in `dllShareData`, retaining its static and dynamic loading interface. - examples/AROS: give the primary-colour graphics smoke one balanced framebuffer lock/unlock path and handle fixed test-marker creation failure before any output transfer. - examples/manual preprocessor: retain the FBlite non-escaped-literal lesson's deliberately late `Option Escape` and backslash forms with exact documented strict-lint annotations and a native output smoke. - examples/manual arrays: make the array-parameter splitter reserve exact output capacity in one `ReDim Preserve`, retain an existing destination range, and guard empty result bounds before display or reuse. - examples/manual error handling: retain the procedure-local `On Error`, `Err`, and `Erfn` compatibility lesson with exact documented lint annotations and compile it under its required `-e` option. - examples/manual graphics: declare the regulated-animation WinMM timer imports CDECL with their fixed 32-bit `ULONG` ABI types on both Windows widths. - examples/manual threads: document the critical-section FAQ's deliberate unsynchronized shared state and mutex contrast, and seed its worker-coordinate random sequence before creating the thread. - examples/manual New/Delete: check failed Cat and Dog custom array allocations, document their virtual ownership release, and state the fixed two-element indexing contract in the polymorphic array lesson. - examples/manual operator overloading: guard null smart-pointer RTTI input, make the three-element demonstration array explicitly zero-based, and document the protected RTTI dereferences. - examples/manual recursion and UDT: make the fixed quicksort data range explicit and guard its initial bounds; make the ZSTRING-chain ownership, empty-source copying, allocation failure, and replacement-before-release paths safe. - examples/manual switches and system: retain the intentional FBlite OPTION-order and escaped-literal lessons with exact annotations, traverse resized arrays by their real bounds, use the fixed 32-bit C varargs form in the escaped printf demonstration, and make the Windows IsRedirected child launch quote its own executable paths and check Shell failure. - tooling/fblint: recognize Constructor, Destructor, Operator, and Property as language keywords during undeclared-name analysis, so valid EXIT procedure-kind syntax does not report FBL310; add constructor/operator EXIT regression coverage. - examples/Win32 VARIANT: initialize every direct OLE Automation result and shift temporary before use, return a valid empty result on failed ordinary operations, and retain the prior target on failed compound operations; apply the same result-lifetime rule to shared primitive-operation macros. - tooling/fblint: recognize `VariantInit` as initializing its addressed output argument, with a data-flow regression fixture. - examples/sfxlib: document composer-grid editor/file/audio ownership, reject failed graphics setup, handle an unknown entry mode safely, name MIDI byte shifts, and widen MIDI render-length arithmetic before conversion. - examples/libzip: validate nullable archive-name and entry-handle results, close an opened output unit when its input entry cannot open, and guard mutable parent-path dereferences. - examples/graphics and PostgreSQL: make input-demo scratch-array bounds explicit, split its initialized mouse state, read optional libpq connection configuration from FBC_PG_CONNINFO without a sample password, and reject failed libpq connection/query handles. - examples/manual arrays: retain the ERASE empty-array and FBARRAY raw-descriptor lessons with exact documented lint annotations and reject a missing descriptor before inspection. - tooling/fblint: classify the FreeBASIC COLOR statement as a keyword during undeclared-name analysis, with a focused parser regression fixture. - examples/manual DATA and dialects: rely on natural module completion before DATA records, state the fixed five-element ranges explicitly, remove surplus RESTORE whitespace, and retain the conditional __FB_LANG__ Option Explicit lesson with exact annotations. - examples/fbgl: seed the anti-aliased line demo before using Rnd and normalize its mixed indentation. - examples/manual errors and object lifetime: retain the ERFN and ERMN FBlite error-handler lessons with exact -exx annotations, make constant-expression integer conversion explicit, and harden simple polymorphic New/Delete allocation failure and cleanup paths. - examples/manual libraries, graphics, and threads: give varZstring checked allocate-before-release ownership, seed and correct VIEW PRINT loop nesting, and document CONDWAIT shared-state synchronization. - examples/manual UDTs: replace non-ASCII relationship punctuation, initialize the aggregation pointer, and reject a failed Vehicle allocation before dereference. - examples/manual libzip and libffi: validate nullable libzip entry results and checked parent-path access; require the libffi closure's console stream to open before callback binding and use line-oriented output for its captured text. - examples/cryptlib and libffi: retain each hashing context through checked failure cleanup, bound pointer-width file-position differences before cryptlib's 32-bit input call, and preallocate two-digit digest output; apply the checked console-stream and nullable closure-release pattern to the duplicate libffi closure example. - tooling/fblint: treat source explicitly identified as an extracted FreeBASIC Manual example as a teaching context for FBL301 Shared declarations, while retaining the warning for ordinary undocumented Shared state; add both regression boundaries. - examples/GDI+, SDL, and manual basics: initialize and validate GDI+ output objects before drawing, document the framework's GUI-thread shared state, check the WIDTH graphics-mode setup, make fixed array lower bounds explicit, validate packed SDL cursor dimensions before allocating masks, and seed the SDL line demo before it uses Rnd. - examples/CUnit and manual UDT/arrays: use an anonymous C-runtime temporary stream rather than a predictable test filename, match `fprintf` arguments to the C ABI, guard a generic byte-array formatter before bounds use, and make ordinary fixed example arrays explicitly zero-based without changing examples whose purpose is implicit-bound syntax. - examples/manual graphics and input: check requested ScreenRes modes before drawing in the BLOAD, COLOR, PSET, POINT, FLIP, DRAW, DRAW STRING, GET, IMAGECONVERTROW, IMAGECREATE, IMAGEINFO, LINE style, PAINT, PCOPY, PIXELPTR, PMAP, PUT, RGB, RGBA, SCREEN Function, SCREENCONTROL, SCREENEVENT, SCREENGLPROC, SCREENLOCK, SCREENRES, SCREENSET, GETMOUSE, MULTIKEY, and SETMOUSE samples; stop BLOAD, GET, RGBA, custom DRAW STRING, and PUT before drawing when their ImageCreate calls fail, release earlier PUT sprites when a later image allocation fails, clean both IMAGECONVERTROW buffers if later setup fails, stop BLOAD palette work when its image file cannot load, and document yielding poll delays. - examples/manual gfxlib FAQ: check the display mode and working image before the image-header example draws or inspects its buffer. - examples/FreeType: initialize library and face owners, release each acquired handle on every later failure and after display, and check ScreenRes before traversing the rendered glyph bitmap in both character examples. - examples/FreeImage: validate flip and 32-bit conversion results, dimensions, ImageCreate, and source bits before copying rows; release each acquired FreeImage object on every error path, check the display mode, and avoid destroying an empty output image. - examples/GIFLIB: check graphics setup, decoder results, frame dimensions, color-map state, palette count, raster storage, and palette indices before drawing; centralize GIF decoder close and release a partial image on malformed input. - examples/GTK+: check the fallback ScreenRes result after GTK initialization fails, reporting the unavailable graphics mode without attempting its prompt. - examples/manual declarations: separate independently initialized values for clearer review across array, control, graphics, operator, procedure, iterator, recursion, reference, UDT, and scope lessons; retain documented colon-sequence demonstrations, and make the public Rational cast reject a zero denominator before division. - examples/DOS, OpenGL, Win32, JIT, and COM: separate independently initialized values; give NeHe's OBJ parser a 32-bit C `%d` destination on 64-bit hosts and document its scene-buffer ownership and shared render state. - examples/manual arrays and threads: distinguish fixed non-empty tables from dynamic input, capture and test dynamic-array bounds before traversal, return a zero count for empty function-array input, preserve documented bound conventions with exact annotations, and derive the Java JNI option count from its fixed storage size. - tooling/fblint: avoid treating parentheses in TypeOf, fixed STRING/ZSTRING/WSTRING type expressions, generic type macros, and generated identifier macros as implicit array bounds; add a focused regression fixture while retaining ordinary FBL-OPT-003 coverage. - examples/manual pointers and comparisons: state the zero lower bound of fixed demonstration arrays without changing their element count or addresses. - examples/event loops: document intentional Sleep use for animation, audio, browser, timer, close-event, and input-poll cadence, using narrow loop-review annotations while retaining the general diagnostic. - examples/emscripten WebSocket: document the callback-owned socket state and URL lifetime through socket creation, retaining the asynchronous browser-event model with exact lint annotations. - examples/pure abstract COM optimization: document the intentional module-level interface outputs used by the optimizer exercise, retaining the narrow shared-state boundary. - examples/OpenGL: state zero lower bounds for extension, NeHe texture, wave-grid, and temporary bitmap arrays without changing their indexing or capacity. - examples/DOS graphics: seed text, Mode X, and VGA random screen data once before drawing so each run does not begin with the same sequence. - examples/MySQL, GTK, PCRE, and TRE: state zero lower bounds for ordinary fixed result, image, XPM, and match arrays; document the GTK RGB buffer's initialization-to-expose callback boundary. - examples/callback state: document the intentional module state shared by CACA, DOS ISR, FreeImage, Allegro, FreeType, OpenGL, SDL, TinyPTC, GTK, Win32, wxWidgets, sfxlib, and Expat callbacks or helpers, retaining exact lint boundaries for ordinary undocumented global state. - examples/Win32 and manual ZSTRING: document string owners that outlive synchronous class-registration and folder-dialog pointer borrows, plus the object-owned ZSTRING conversion buffer, retaining exact lifetime annotations. - examples/manual allocations and PCRE: check placement-new, UDT, and helper allocations before dereference while retaining null propagation from overloaded New; initialize the PCRE wrapper's owners, validate setup and match-vector allocation, and reject calls without valid parser storage. - examples/manual threads: document mutex-lock ownership for shared predicates, handles, output, and screen state, and identify the deliberately unsynchronized flag lessons as contrasts rather than thread-safe patterns. - examples/DOS and manual graphics: identify Screen 13 as the intended compatibility mode for historical graphics and extender lessons, retaining the compatibility demonstration without implying a general target fallback. - tooling/fblint and examples/logical operators: recognize parenthesized Not conditions as an explicit precedence boundary while retaining unparenthesized diagnostics; update OpenGL keyboard and logical lessons, retaining the documented comparison notation example. - examples/TGA and Win32 COM: document raw comparisons constrained to exact TGA header arrays and fixed GUID values; name the browser client site's two interface comparison results before interface selection. - examples/OpenGL, GLib, GooCanvas, and HTTP: name viewport dimensions, inactivity timeouts, and the HTTP service port, document fixed logical canvas bounds at their API calls, and make the HTTP socket-error sentinel conversion explicit. - examples/manual arrays and UDTs: document intentional replacing ReDim lessons and destination resizing immediately followed by complete source-array copies. - examples/pointers and lifetime: check allocated and renderer-derived pointers before use, and retain the local/static lifetime lesson without dereferencing expired local storage. - examples/manual flow control: identify deliberate GOTO sites in syntax, generated-label, FBlite-label, and recursion-to-iteration lessons while retaining the general flow diagnostic for ordinary code. - examples/DOS and SDL: seed random visual output before first use, and use SDL_ttf's 32-bit Long text-metric outputs to match its C ABI on every host width. - examples/GTK, manual strings, and PCRE: build repeated decimal formatting in one operation, preallocate the WHILE/WEND reversal result, and document the intentionally short bundled PCRE regression input. - examples/manual options: document intentional conditional and FBlite option ordering used to contrast GOSUB, default argument passing, and linkage behavior. - examples/Windows DDK driver: align DriverEntry, fb_RtInit, and KeTickCount definitions with their declared StdCall aliases, preserving the linker-visible driver ABI. - examples/ANY, implicit operators, and PCRE: document fixed or checked pointer-index bounds beside the indexed operation, retaining the lessons and wrapper behavior without accepting unbounded indexing. - examples/DOS and gas64 assembly lessons: identify target-specific inline assembly at the assembly boundary and retain their documented source-target requirements. - examples/includes: give direct-use DLL, OpenGL texture, Win32 resource, manual helper, generic, sfxlib, timer, VARIANT, and WinMM headers individual preprocessor guards, retaining their existing declarations and tutorials while making repeated inclusion safe. - tooling/fblint: recognize type-first `Dim As Function (...)` and `Dim As Sub (...)` procedure-pointer declarations with whitespace before the parameter list, retaining FBL-OPT-003 for actual implicit arrays and adding a regression fixture. - tooling/fblint: ignore credential vocabulary only in the commented `Declare` signatures emitted by imported COM type libraries, while retaining `FBL008` for executable credential assignments and ordinary comments. - examples/QuickLZ: validate every QuickLZ state and buffer allocation, release and clear owned pointers on each error path, use an `Integer` file unit returned by `FreeFile`, and document the compression routines' resource ownership. - examples/manual LZO: allocate result buffers only after codec initialization, check every allocation, remove the unused decompression-workspace allocation, and release/clear all owned storage on failure and success paths. - examples/manual zlib: use zlib's `uLong_` length ABI type, check source and destination allocations, seed generated test data, and release/clear buffers before every error or normal exit. - examples/manual ALLOCATE: identify the two deliberate unchecked allocations in the leak demonstration with narrow `FBL800` next-line suppressions, while retaining unsuppressed diagnostics for normal code. - tooling/fblint: keep layout diagnostics `FBL015` through `FBL019` in the explicit style profile, and distinguish `New Type[count]` allocation syntax plus `Operator New[]` declarations from indexed pointer access in `FBL525`; add profile-boundary and pointer-allocation regression coverage. - tooling/fblint: end local unreachable-code analysis at completed Function, Sub, Property, Constructor, Destructor, and Operator routines, preventing `FBL610` and `FBL-CF-001` from carrying a `Return` into following declarations; add property-boundary regression coverage while retaining same-routine unreachable-code diagnostics. - examples/bzip2: make the streaming compression sample validate input and output buffers, preserve the old output buffer when `Reallocate` fails, reject output-size overflow, check bzip2 status results, and release/clear every owned buffer through one caller-level cleanup path. - examples/libpng: validate `ScreenRes`, libpng setup, image allocation, and row-buffer allocation; centralize local resource cleanup while preserving image-result ownership; and document the libpng callback and row-conversion bounds that are safe but not inferable by the linter. - examples/libjpeg: validate `ScreenRes`, decoder row allocations, and output-image allocation; centralize partial-read cleanup; reject null decoded images before drawing; document bounded row conversion; and retain both `fb` and `fblite` compatibility by using the legacy `Long` pitch output expected by fblite `IMAGEINFO`. - examples/manual GMP: check the GMP-number and generated-string allocations before use, release and clear each owned pointer only after its successful allocation, and document the example's ownership policy. - examples/manual CAST: check the `New` and `Callocate` demonstration allocations before dereferencing them, pair successful allocations with the matching release operation, clear the released pointers, and document the ownership distinction. - examples/manual ZSTRING and WSTRING: check their fixed-buffer allocations before dereferencing them, retain the existing 12-character examples and terminator space, release and clear the buffers after use, and document ownership. - examples/manual WITH: validate the rectangle-array allocation before its dereferenced WITH block, preserve the five-element demonstration, release and clear the owned buffer, and document its lifetime. - examples/manual DIM: validate the dynamic ZSTRING allocation before assignment, keep the normal size output, release and clear the buffer after its final use, and document ownership. - examples/manual CLEAR: check the raw 20-byte allocation before clearing or reading it, retain the two raw-memory `Clear` demonstrations, and release and clear the one owned pointer after the output loop. - examples/OpenGL BMP and manual FIELD: document the exact raw BMP and TGA header byte ranges, and use the BMP specification's fixed-width signed and unsigned fields so the loader keeps its 14-byte and 40-byte headers on 64-bit hosts. - examples/OpenGL TGA: validate the compressed-loader scratch-pixel allocation, release it on both decode failure and success, clear released image pointers, and compare the documented header byte arrays directly instead of treating the enclosing UDT as raw storage. - examples/manual FIELD: obtain and check a `FreeFile` unit before reading the documented BMP header, display dimensions only after a successful transfer, and use a narrow `FBL-DOC-BIN-003` suppression for that reviewed raw-format demonstration. - examples/text-file reads: limit the GTK text viewer and manual Binary/GET string-loading examples to 4 MiB, measure each file once with `LongInt`, retain empty-file behavior, and report or return an empty result when a read fails or exceeds the demonstration's bound. - examples/manual GET: pass the checked binary handle explicitly to each read demonstration instead of using shared module state, report failed opens, reject a failed temporary allocation before dereferencing it, and document the handle and buffer ownership rules. - examples/manual PUT buffer: validate the 256-byte allocation and binary open before use, report a failed write, close the checked `FreeFile` handle before releasing the buffer, and document the exact raw-byte output with a narrow format-rule suppression. - examples/manual UDT GET/PUT: document the 40-byte same-target tutorial record, check every open and raw transfer, close each method-owned handle, and use narrow record-layout and fixed-string-policy suppressions only beside the documented fields and transfers. - examples/manual RANDOM: document the 11-byte and 24-byte same-target tutorial record layouts, use checked `FreeFile` handles for every RANDOM read/write pass, and leave the record data outside the guarded I/O flow. - examples/error handlers and OpenGL object loading: use local `FreeFile` units and close a successfully opened file before normal return or handler teardown, retaining the original failed-open behavior. - examples/manual BINARY and CLOSE: use checked `FreeFile` handles for the one-value read/write demonstrations, report transfer failures, and retain CLOSE's no-argument form only after its file opened successfully. - examples/manual FOR INPUT/OUTPUT/APPEND and INPUT #: use checked `Integer` `FreeFile` handles, prevent a read pass after a failed write, seed the random output example, and add narrow documented `FBL517` suppressions only to the formatted statements those pages teach. - examples/manual FILEFLUSH and FREEFILE: check every acquired handle before use, close only successfully opened streams in acquisition order, retain the flush visibility sequence, and document the one raw string transfer with a narrow suppression. - examples/manual ENCODING, ACCESS, CONS, LPT, PRINT, RESET, and FREEFILE: use checked handles and close each acquired resource; bound byte inspection before allocation; preserve explicit console/printer devices and named manual fixtures with narrow documented suppressions; and retain the deliberately colliding FREEFILE teaching case with checked failure handling. - examples/manual file I/O device, OPEN, PUT, SEEK, LOF, LOCK, WRITE, and CRT comparison pages: use checked `FreeFile` handles and successful-path cleanup, preserve statement-only device opens with immediate `Err` checks, document same-target raw records and formatted WRITE statements at their exact transfers, and avoid a fixed `.tmp` fixture name. - examples/manual FILEATTR and FILESETEOF: use checked owned handles, obtain the CRT file pointer only after a successful open, and perform each resize pass only after the preceding pass closed. BSAVE samples now check graphics-mode setup and image-buffer allocation before drawing or saving, and use real coordinate division where the circle aspect is non-integral. - examples/manual CVA_ARG and VA_FIRST: guard the format-string pointer before its first dereference, use a descriptive remaining-character counter, and retain the backend-specific variadic ABI demonstrations. - examples/manual procedure-pointer vtable examples: handle a failed object allocation before dereference and use a virtual-procedure selection macro that checks the vtable index before resolving a member procedure or cast. - examples/manual overloaded NEW: check the aligned allocation before layout arithmetic, use byte-pointer arithmetic for that layout, clear released owner pointers, and document the reserved header-slot access that retrieves the original allocation. - examples/manual SELECT CASE speed benchmark: retain each non-overlapping scalar case after its preceding range and document narrow range-order suppressions at those exact cases. - examples/manual ERR, BLOAD/BSAVE workaround, AS, and error-handling pages: use local checked file numbers, close successful opens, validate the caller-owned buffer before raw compatibility I/O, and retain the QB-only ON ERROR scope with a narrow documented suppression. - examples/manual legacy ON ERROR, ERR, ERL, RESUME, and RESUME NEXT pages: document the deliberately active handler, protected handler label, Err read, and resume behavior with exact narrow suppressions. The dynamic-array sizing page likewise documents its intentional unsized-array metadata queries, one-based dimension loop, and post-ERASE sizing report. - examples/manual CUSTOM, SCREENCONTROL, and regulated-animation graphics pages: check graphics setup before drawing, check the custom image allocation, seed random motion once, name dither and position constants, document event-poll pacing, and separate initialized animation declarations including the floating animation phase. - examples/manual regulated point-cloud animation: reject unavailable graphics setup and an empty generated cloud, allocate the cloud once before its nested-coordinate loops, use its recorded element count for rendering and sorting, guard the perspective divide near zero, and correct the Z-axis wrap condition. - examples/manual error-handling comparison: retain the four unchecked, result-returning, and legacy-handler OPEN variants; close only successful opens; document their literal unit, handler, and label behavior with narrow suppressions; and state that failed opens never acquire the unit. - examples/manual dynamic memory: check the Callocate and New[] object arrays before use, retain the original owner until Reallocate succeeds, pair every manually constructed object with its destructor, clear released owners, and document the exact placement-New buffer and fixed teaching loops. - examples/manual overloaded NEW manager: record one bounded bookkeeping slot per successful allocation, shrink that table outside its cleanup loop, use the table bounds while searching it, and release all remaining tracked allocations before the deliberate exhaustion stop. - examples/manual NEW and DELETE operators: report failed overloaded allocations before use, release and clear ordinary owners, clear fixed descriptor slots explicitly, bound the placement buffer to two UDT objects, and document the manual placement destructors. - examples/manual RTTI information pages: check object and mangled-name pointers before dereference, document each intentional compiler-layout slot access with narrow suppressions, preserve short hierarchy-name assembly, and use an explicit negative-base traversal that avoids compiler loop-direction warnings. - examples/manual sample builder: grow special-build, directory, and source-file tables geometrically while retaining explicit active counts; centralize two-sided INI whitespace parsing; name the compiler path distinctly from an invocation; and document the source-enumeration and module-exit exceptions. - examples/manual dynamic object lifetime: replace direct Reallocate assignment with replacement-buffer ownership, preserve the old string on allocation failure or self-aliasing assignment, report a released object safely, and keep the caller's New owner separate from its ByRef alias. - examples/manual TLS emulation: document sentinel-slot ownership and old-runtime mutex coverage, expose the macro-generated TLS accessor declaration to analysis tools, check the temporary object-relocation allocation, and keep bounded compaction operations annotated at their exact layout boundary. - examples/manual recursion-to-iteration quicksort: state the fixed zero-based 100-byte shared demonstration buffer, split initialized sort-state declarations, and pass the buffer's documented bounds to both recursive and stack-based variants. - examples/manual EXTENDS ZSTRING: give the derived string a checked CAllocate owner, preserve old text through failed growth or self-aliasing assignment, support its documented null default as an empty string, and precompute SELECT CASE comparison values outside the case list. - examples/manual ERASE bounds: document the deliberate before-and-after fixed/dynamic bound queries, preserving the page's post-ERASE observation while limiting array-state suppressions to those exact reports. - examples/manual MUTEXCREATE and CONDCREATE: document thread, synchronization-object, and point ownership; seed the circle generators once; use explicit integer center coordinates; and distinguish the callback procedure-pointer declaration from an array. - examples/manual critical-section display FAQs: document mutex-protected display state where used and the small encoded thread-number argument, then widen that pointer conversion before reducing it to the known 1-through-9 range. - examples/manual frame regulation include: add a one-time include guard, declare Win32 time-period functions with their documented StdCall/32-bit ABI, correct the fallback threshold parameter, and return neutral timing values for zero FPS or a non-advancing timer. - examples/manual integer division: document the two deliberate non-integer divisor coercions that demonstrate `\` rounding behavior, with suppressions limited to those teaching expressions. - examples/manual Operator Is: reject a null Object pointer before the RTTI checks and derived-type member access, retaining the unknown-object result for both null and non-Vehicle inputs. - examples/manual Operator Let: check constructor and assignment string allocations with `FB_RTERROR_OUTOFMEM`, allocate replacement storage before releasing the old value, and document the UDT's one-owner string lifetime. - examples/tinyptc Mandelbrot: normalize the three internal function section banners to the documented 73-dash form without changing the renderer. - examples/manual LINE INPUT: document that maxlength includes the ZSTRING terminator, validate the input-buffer allocation before dereferencing it, and release and clear the buffer after the bounded input example. - examples/manual LINE INPUT #: use `FreeFile` for each checked handle, prevent reads after the fixture write fails, check all input-buffer and I/O boundaries, release and clear the bounded ZSTRING buffer, and retain documented narrow linter suppressions only for the deliberate named fixture and immediate `Err` status reads. - tooling/fblint: recognize an exact routine-level `If p = 0 Then ... Return ... End If` guard, including the established parenthesized spelling, as proof for later `*p` dereferences; keep nested guards unsafe and cover both boundaries with regression fixtures. - tooling/fblint: make `FBL-STR-002` require a locally provable `CAllocate(Len(text), SizeOf(ZString))` allocation with no terminator space, and make `FBL-STR-003` require that a dereferenced LINE INPUT target actually lacks a trailing maxlength; add safe and unsafe regression fixtures for both rules. - tooling/fblint: keep `FBL804` for an object-style `Clear name`, while excluding function-style and multi-argument raw-storage forms, indexed elements, and enum members; add positive and safe fixture coverage for the boundary. - tooling/fblint: accept an exact `If p <> 0 Then` or `ElseIf p <> 0 Then` pointer proof only inside its active branch, and invalidate it at `Else`, matching `End If`, or assignment to `p`; retain `FBL-PTR-001` and `FBL-PTR-002` for the unproven paths with regression coverage. - tooling/fblint: restrict simple CASE duplicate tracking to expressions that remain comparable after literal stripping; concatenated selectors such as `EXTCHAR & "G"` are no longer collapsed into false duplicates. - tooling/fblint: exclude Delete[] operator declarations and definitions from pointer-index bounds checks, matching the existing New[] allocation syntax boundary and preserving FBL525 for actual indexed pointer access. - tooling/fblint: recognize `New(storage) Type[count]` as an allocation count rather than pointer indexing, with placement-NEW fixture coverage while retaining FBL525 for actual pointer subscripts. - build/release: make GitHub Release publication independent of an implicit checkout, stage multi-gigabyte uploads with hard links, allow enough time for the complete asset set, and provide a publish-only recovery workflow that reuses artifacts from a completed package run. - build/Android runtimes: build packaged runtime archives with optimization enabled, and keep generic ARMv7 C and C++ objects on the armeabi-v7a VFPv3-D16 baseline even when a recent NDK Clang driver enables NEON by default; the isolated gfxlib2 and sfxlib NEON objects still use runtime AT_HWCAP checks. - compiler/DOS WSTRING: keep DOS literal folding and narrow-to-WSTRING conversion compatible with DJGPP's byte-sized WSTRING representation, retain raw non-ASCII literal bytes where required, and avoid folding mixed literals through an incompatible wide-character conversion. - compiler/restarts and gas64: preserve the stage-one assembly filename when `#cmdline` changes intermediate-file retention during a parser restart, and restore the virtual-register mapping after gas64 materializes a multiply operand so array-index arithmetic uses the correct physical register. - compiler/namespaces: search enclosing namespace imports when resolving enum elements during procedure parsing, preserving local enum precedence over same-named global constants. - rtlib/gfxlib2/DOS: serialize DJGPP timer, heap, DPMI and DOS bridge state for the optional scheduler, keep deferred scheduling out of private IRQ stacks, use valid selector aliases during asynchronous dispatch, mask PIC status reads to their defined width, preserve the VESA bank-switch wrapper's C ABI registers, and keep the conservative DPMI-yield default unless explicitly enabled. - compiler/bindings: prevent disabled sfxlib procedures from blocking declarations or preprocessor definitions while retaining active system commands, and correct standalone binding aliases, callback calling conventions, Windows macro guards, DDK byte-sized fields, `FormatMessage` argument-list pointers, RPC base types, and D3DX9 effect/shader include dependencies. - rtlib/DOS lifecycle: keep ordinary no-thread DOS event mutex creation usable for graphics setup, preserve the existing unsupported `ThreadCall` contract without a libffi provider, and retain scheduler-safe cleanup when threaded runtime or sfxlib shutdown begins. - examples/manual and platform samples: retain QB suffix, numeric-rounding, integer-coercion, and line-continuation teaching cases with exact documentation, compile the line-continuation layouts without duplicate definitions, make DirectDraw ABI clearing use unambiguous structure sizes, format string-buffer addresses at pointer width, and check printer and AROS smoke output opens before use. - tooling/fblint: defer `FBL-OPT-008` until the full QB compatibility module is known, require a routine before suggesting `Option Private`, and add safe and unsafe regression fixtures for the delayed decision. - examples/manual, threading, networking, and Unicode: make integer-width conversions and refreshed string borrows explicit, bound the local thread table, avoid an invalid-state timer busy loop, document intentional legacy-control and character-boundary lessons, and record the TCP handle/timeout contract. - tooling/fblint: avoid treating `Integer Ptr` casts as pointer-to-integer conversions, and limit the large-static-array diagnostic to fixed `Dim` declarations rather than large scalar expressions; add positive and safe regression fixtures for both heuristic boundaries. - examples/Win32 VARIANT: return an independently owned BSTR from the WSTRING-pointer conversion, release the temporary VARIANT result, and state the matching `SysFreeString` caller cleanup contract. - tooling/fblint: keep FBL009/FBL010 presentation guidance in the explicit style profile, and distinguish nonzero decimal loop steps from STEP 0; add profile-scope and decimal-boundary regression fixtures. - examples/manual and Expat: replace literal file units with `FreeFile` owners, close completed Expat input, use the binding's typed character-data callback, qualify TUI receiver calls, and state dynamic-array bounds where their construction proves a nonempty range. - tooling/fblint: restrict package-glob warnings to package/release operations, and recognize an explicit Unicode macro or byte-order mark as a reviewed source-encoding contract while retaining FBL004 for unmarked non-ASCII text. - tooling/examples: complete a strict Windows lint pass across all 1,722 example sources with zero warnings; retain the separate style profile's legacy indentation and comma-layout advisories instead of mass-reformatting historical examples.