V.A.L.I.D.

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built V.A.L.I.D. (Vectorized Asynchronous Logic & Intelligent Diagnostics) — a lightweight, high-performance state-tracking and business logic framework for .NET 8 and Blazor WebAssembly applications.

Enterprise .NET frameworks like CSLA or state containers like Fluxor are heavily dependent on reflection and heap-allocated tracking collections. V.A.L.I.D. replaces all of that with a zero-allocation compile-time model:

• Bitmask Register State Tracking: Uses System.UInt128 bitmasks to track up to 128 property flags (dirty, error, busy, deleted) in $O(1)$ time with 0 B allocated.
• VDOM & JS Serialization Bypass: Allocates a contiguous native memory slab (UnmanagedSlab) on the WebAssembly linear heap. A JavaScript requestAnimationFrame render loop directly reads the WASM heap (HEAPU8) to surgically update elements, bypassing Blazor's Virtual DOM diffing.
• Roslyn Source Generator: Generates the properties, circular undo/redo history, F# record mappings, and auto-generates unit/fuzz tests.
• F# Rules Engine: Projects C# states onto immutable F# struct records, resolving offline-first replication conflicts with mathematical Add-Wins Observed-Removed Set (AWORSet) CRDTs.

Demo

• GitHub Repository: UnitBuilds-CC/V.A.L.I.D.
• Official Documentation: V.A.L.I.D. Wiki

Architecture Overview

Below is the visual flow of our surgical WASM bypass architecture:

Performance Benchmarks

Here are the official BenchmarkDotNet results comparing V.A.L.I.D.'s direct memory write speed against standard Blazor VDOM mutations:

Benchmark Operation	Execution Time (Mean)	Gen 0 / 1000	Allocated Memory	Speedup
VALID Slab direct memory write	6.62 ns	-	0 B	26.7x
F# Rule Evaluation	15.80 ns	-	0 B	10.4x
F# CRDT Convergence	86.48 ns	0.0391	328 B	1.8x
Blazor VDOM Mutation (Baseline)	172.78 ns	0.0048	40 B	Baseline

---

The Comeback Story

Before the challenge, V.A.L.I.D. was an experimental proof-of-concept sitting unfinished in my local directory. The code had compilation bugs, the packaging configuration was broken, and the JS-WASM bridge was prone to memory allocation crashes when the WASM memory buffer resized.

Here is what we did to cross the finish line:

1. Refactored core library dependencies to support clean .NET 8 builds and verified 100% test coverage.
2. Fixed the JS memory relocation bug in our surgical bridge (vavid-bypass.js). We added a background heartbeat inspector that checks a magic pulse header in WASM memory, allowing the JS loop to automatically re-bind to the heap if the WASM buffer resizes.
3. Structured the NuGet packaging pipelines and versioned the assets (VALID 3.0.3 and VALID.FSharp 3.0.1).
4. Created the official release pipeline, pushing tagged releases (v3.0.3) and uploading .nupkg assets to the release tab.
5. Wrote a 6-page comprehensive Wiki covering Core Concepts, Getting Started, Business Objects, Validation Rules, and Blazor Integration.
6. Populated the GitHub Projects board with the Blazor Cashbook Demo to give developers a working sandbox.

---

My Experience with GitHub Copilot

GitHub Copilot acted as an invaluable co-pilot throughout the final polishing process:

• Writing Boilerplate & Generators: Copilot expedited the creation of the Roslyn Source Generator syntax trees, writing the recursive C# property-to-bit mapping code in minutes.
• Debugging Low-Level JS-Interop: Copilot helped write the safety heartbeat and pointer relocation code in JavaScript, ensuring the WASM HEAPU8 array offset changes were handled gracefully.
• Documentation & Wiki Generation: Copilot read our codebase and compiled clear, concise API documentation for our Wiki pages, ensuring the migration path from legacy frameworks (like CSLA) was fully documented.