neo.mjs 10.0.0-beta.5 → 10.0.0

package/.github/RELEASE_NOTES/v10.0.0-beta.1.md

@@ -0,0 +1,20 @@
+## Neo.mjs v10.0.0-beta.1 Release Notes
+
+We are excited to announce the release of Neo.mjs v10.0.0-beta.1, bringing significant architectural improvements, enhanced developer experience, and various stability fixes.
+
+### Key Highlights:
+
+* **Asynchronous Initialization with `initAsync()`**: The `core.Base` class now includes a powerful `async initAsync()` method, allowing asynchronous code to be executed outside of the traditional constructor chain, leveraging the microtask queue. This is a crucial improvement for registering **Remote Method Access** earlier in the application lifecycle, effectively eliminating a previously observed 4ms delay caused by reliance on the macro task queue.
+* **Enhanced `main.addon.Base`**: The `main.addon.Base` class has received substantial enhancements to dynamically load files based on the new `initAsync` mechanism and properly respect the new `isReady_` configuration.
+* **Revamped Learning Content Structure**: The entire Learning Content has been reorganized and moved into a new `learn` top-level repository folder.
+* **Improved Learning Content Rendering**: The comprehensive Learning Content has been significantly enhanced to render more beautifully across different viewing environments. This was achieved by adopting standard Markdown fenced code blocks with info strings (e.g., ````javascript live-preview````). This ensures native syntax highlighting and excellent readability when viewed directly on the GitHub repository. Simultaneously, Neo.mjs's `ContentComponent.mjs` is now capable of dynamically processing these blocks for interactive features (such as `live-preview` and `neo-component` instantiation) and specialized styling (like `readonly` code blocks) within the Neo.mjs website. Specific SCSS adjustments in `ContentComponent.scss` further guarantee consistent and correct rendering of various code block types, including plain text/directory structures, by utilizing precise selectors like `:not(.hljs)` to prevent conflicts with Highlight.js and maintain visual integrity.
+* **Grid and Table Refactoring Polish**: The extensive refactoring of `grid.View` to `grid.Body` and `table.View` to `table.Body` has been thoroughly polished and is now considered fully stable.
+* **Delta Generation Fix**: A critical glitch within the v10 delta generation logic has been fixed, significantly reducing the amount of created deltas and ensuring that changes applied to the DOM are once again minimized to the bare essential.
+
+## Try it out here
+
+`dist/esm`:
+https://neomjs.com/dist/esm/apps/portal/
+
+`dist/production`:
+https://neomjs.com/dist/production/apps/portal/

package/.github/RELEASE_NOTES/v10.0.0-beta.2.md

@@ -0,0 +1,73 @@
+## Neo.mjs v10.0.0-beta.2 Release Notes
+
+This beta release brings significant enhancements across documentation, core framework capabilities, and **a major focus on improving component rendering performance and security**, alongside an enhanced developer experience.
+
+### Documentation & Learning Content
+
+We've made substantial updates to the `learn` section to provide clearer, more comprehensive guidance:
+
+*   **Enhanced Benefits Guides**:
+*   **Forms Engine**: Improved introduction, detailed benefits, and business value connections for state management, unmounted
+*   validation, and nested/lazy-loaded forms.
+*   **Multi-Window Applications**: Expanded use cases and clearer explanations of seamless data/state sharing.
+*   **Quick Application Development**: Detailed how property lifecycle hooks, elegant state management, and powerful debugging
+*   contribute to rapid development.
+*   **Effort vs. Complexity**: Refined explanation of Neo.mjs's linear scaling of effort with complexity, including the initial learning curve.
+*   **Speed**: Improved introduction highlighting web worker benefits for performance.
+*   **Features Summary**: Updated with direct links to detailed benefit guides for easier navigation.
+*   **New RPC Layer Guide**: A dedicated guide (`learn/benefits/RPCLayer.md`) explaining the RPC layer's role in seamless
+*   communication across Web Workers, Main Threads, and backend services, including practical examples.
+*   **Updated Glossary**: The `learn/Glossary.md` has been significantly expanded and polished
+*   **Instance Lifecycle Guide**: New comprehensive guide (`learn/guides/InstanceLifecycle.md`) detailing the synchronous and
+    asynchronous phases of component creation and destruction, including `constructor()` vs. `construct()` and `isReady` concepts.
+*   **Main Thread Addons Guide**: Enhanced with visualizations for remote method access and explanations of `interceptRemotes` for
+    automatic method caching.
+*   **Learning Path Refinements**: The `learn/tree.json` structure has been reordered to provide a more logical learning progression for
+    guides.
+*   **Code Block Improvements**: Various formatting and rendering fixes for code blocks across documentation.
+
+### Core Framework & Features
+
+*   **Remote Method Interception for Addons**: `addon.Base` now intercepts remote calls that arrive before an addon is fully
+    `isReady`, enabling more robust asynchronous initialization for addon methods.
+*   **New Class Hierarchy Manager**: Introduction of `manager.ClassHierarchy` (`#6876`), a new core manager that provides robust
+    class hierarchy information, including memoized `isA()` queries and integration into `Neo.Main` and other workers.
+
+### Rendering & Components
+
+*   **Enhanced VDom Security & Performance (DomApiRenderer Integration)**: A major internal refactoring has been completed to
+    replace `html` with `text` on VDom node properties across
+    hundreds of components (`app/*`, `Neo.*`, `component.*`, `form.field.FileUpload`, `Neo.calendar.view.*`, `Portal.view.*`). This
+    significant change leverages the `DomApiRenderer` introduced in v10 to:
+    *   **Improve Security**: By defaulting to `text` content, Neo.mjs now inherently prevents Cross-Site Scripting (XSS) vulnerabilities
+        by escaping HTML, making applications more secure by design.
+    *   **Boost Performance**: Direct text manipulation is generally more performant than parsing and injecting HTML, leading to faster
+        and more efficient DOM updates.
+    *   **`component.Base` `text_` Config**: Added a new `text_` config to `component.Base` for direct text content management.
+    *   **Grid/Table Rendering**: `grid.Body` and `table.Body` now support the `text` property in `applyRendererOutput()`, offering an
+        alternative to `html` for rendering.
+
+### Internal Improvements & Refactoring
+
+*   **`main.DeltaUpdates` Enhanced Initialization**: The `main.DeltaUpdates` module now utilizes `initAsync()`, a significant
+    improvement for its initialization process, alongside updated JSDoc comments.
+*   Minor code cleanups and method reordering in `vdom.Helper`.
+*   Minor fixes in `component.MagicMoveText` and `Portal.view.learn.ContentComponent`.
+
+ ---
+
+This release focuses heavily on improving the learning experience and solidifying core architectural patterns. We encourage you to explore the updated documentation and leverage the new features for more robust and performant applications.
+
+All changes in 1 commit: https://github.com/neomjs/neo/commit/ee8ccd1943a4fc198ec440dcb44146c9f1787193
+
+### Call To Action
+
+We're excited for you to dive into the enhanced learning experience!
+
+*   **Explore the New Guides**: Discover the power of Neo.mjs by exploring updated sections like
+    * [Main Thread Addons Guide](
+      https://neomjs.com/dist/esm/apps/portal/#/learn/guides.MainThreadAddons)
+    * [Forms Engine benefits](https://neomjs.com/dist/esm/apps/portal/#/learn/benefits.FormsEngine)
+    * [Glossary](https://neomjs.com/dist/esm/apps/portal/#/learn/Glossary).
+*   **Share Your Feedback**: Your input is invaluable! Please let us know what you think, report any issues, or suggest further
+    improvements via [GitHub Issues](https://github.com/neomjs/neo/issues) or our [Slack Channel](https://join.slack.com/t/neomjs/shared_invite/zt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA).

package/.github/RELEASE_NOTES/v10.0.0-beta.3.md

@@ -0,0 +1,39 @@
+## Neo.mjs v10.0.0-beta.3 Release Notes
+
+This beta release significantly expands our learning resources, introducing **seven new comprehensive guides** designed to accelerate developer onboarding and mastery of the neo.mjs framework. We've also invested in enhancing the overall styling and user experience of the learning section.
+
+### Documentation & Learning Content
+
+We are excited to announce a major update to the `learn` section, with seven new guides to provide in-depth knowledge on key neo.mjs concepts.
+
+**For the optimal learning experience, including live code previews and interactive examples, we strongly recommend viewing these guides on our website: [neomjs.com#/learn](https://neomjs.com/dist/production/apps/portal/index.html#/learn)**
+
+*   **New In-Depth Guides**:
+    *   **Collections**: A comprehensive guide to understanding and utilizing neo.mjs collections for efficient data management.
+    *   **Custom Components**: Learn how to create your own custom components to build modular and reusable UI elements.
+    *   **Extending neo.mjs Classes**: A guide to extending the framework's core classes to add custom functionality and behavior.
+    *   **Forms**: Learn how to build powerful and flexible forms with the neo.mjs forms engine.
+    *   **Layouts**: A guide to using layouts to create responsive and adaptive user interfaces.
+    *   **Records**: An in-depth look at working with data records, a fundamental aspect of the neo.mjs data package.
+    *   **ComboBox Field**: A dedicated guide to the versatile ComboBox field, covering its configuration and use cases.
+*   **Enhanced Learning Experience**:
+    *   The styling of the learning section has been improved for displaying code blocks inside headlines and code blocks inside lists.
+---
+
+This release is focused on empowering developers with the knowledge and resources needed to build exceptional applications with neo.mjs. We encourage you to explore the new guides and see how they can help you in your projects.
+
+All changes in 1 commit: https://github.com/neomjs/neo/commit/c68a0c9fab1d5578bbd5120ba97bbd7707093b7c
+
+### Call To Action
+
+We're excited for you to dive into the enhanced learning experience!
+
+*   **Explore the New Guides**: Discover the power of Neo.mjs by exploring the new guides on our website:
+    *   [Collections](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.Collections)
+    *   [Custom Components](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.CustomComponents)
+    *   [Extending neo.mjs Classes](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.ExtendingNeoClasses)
+    *   [Forms](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.Forms)
+    *   [Layouts](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.Layouts)
+    *   [Records](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.Records)
+    *   [ComboBox Field](https://neomjs.com/dist/esm/apps/portal/#/learn/guides.form_fields.ComboBox)
+*   **Share Your Feedback**: Your input is invaluable! Please let us know what you think, report any issues, or suggest further improvements via [GitHub Issues](https://github.com/neomjs/neo/issues) or our [Slack Channel](https://join.slack.com/t/neomjs/shared_invite/zt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA).

package/.github/RELEASE_NOTES/v10.0.0-beta.5.md

@@ -0,0 +1,70 @@
+## Neo.mjs v10.0.0-beta.5 Release Notes
+
+This beta release dramatically expands on the reactive programming model introduced in beta.4, delivering a powerful, end-to-end **Effect-Based Reactivity System**. This new system provides a declarative and highly efficient way to manage component state, create reactive data transformations, and build dynamic user interfaces with minimal boilerplate.
+
+This release also includes significant enhancements to the framework's mixin system and state providers, further improving code organization and state management capabilities.
+
+### Core Framework & Features
+
+A core philosophy of Neo.mjs is to provide developers with powerful, flexible options. This release reinforces that principle by dramatically enhancing the framework's reactive core. These new features provide a more direct, declarative way to manage state and build UIs—offering a familiar entry point for developers from other ecosystems—while seamlessly integrating with the established power and productivity of Neo.mjs's declarative component tree architecture.
+
+The pace of innovation in this release is a testament to the power and flexibility of the new architecture. The features introduced in this beta represent a quantum leap forward, enabling development patterns that are more declarative, more powerful, and more intuitive than ever before.
+
+#### 1. The New Effect-Based Reactivity System
+
+The core of this release is a new suite of classes (`core.Effect`, `core.EffectManager`, `core.BatchEffectManager`) that enable true "spreadsheet-style" reactivity. An "Effect" is a function that automatically re-runs whenever any of its reactive dependencies change.
+
+*   **Automatic Dependency Tracking**: The framework now automatically tracks which reactive configs are accessed within an Effect. You declare a config as reactive by adding a trailing underscore in the `static config` block (e.g., `myValue_`), and then access it without the underscore (`this.myValue`). You no longer need to manually subscribe to changes; the dependency graph is built and maintained for you.
+*   **Arbitrary Cross-Instance Bindings**: Since bindings are now powered by `core.Effect`, they can depend on any reactive config from any `core.Base` instance—not just components or state provider `data`. This allows for creating powerful, arbitrary data flows between any part of your application (e.g., binding a component's property to a data store's `count`).
+    ```javascript
+    // A component can now bind its text to its provider's data AND a store's count
+    bind: {
+        text: data => `${data.title}: ${myStore.count} items`
+    }
+    ```
+*   **Synchronous Batching (`core.BatchEffectManager`)**: Multiple state changes can be batched together into a single, atomic update. This prevents "glitching" (where the UI updates multiple times for a single user action) and ensures that effects run only once with the final, consistent state.
+*   **Foundation for Declarative VDOM**: The new Effect system lays the groundwork for a truly declarative component model. As a proof-of-concept, a new `button.Effect` class was created to demonstrate that a component's VDOM can now be generated by a single, reactive function that automatically re-runs when its state dependencies change. This powerful new paradigm, which will be fully realized in the upcoming **[Functional Components](https://github.com/neomjs/neo/issues/6992)** epic, will make component rendering logic more readable, centralized, and easily extensible.
+*   **Lifecycle-Aware Subscriptions**: A new `core.Base#observeConfig()` method provides a safe, convenient way to subscribe to config changes, automatically handling the cleanup of subscriptions when a component is destroyed to prevent memory leaks.
+
+#### 2. Architectural Evolution: State Management Overhaul
+
+`state.Provider` has been completely rewritten to be more powerful, explicit, and performant, leveraging the new Effect-based reactivity core. This is a significant architectural evolution from the previous version.
+
+**The Old System:** Bindings received a single, implicitly merged `data` object, which was a combination of all state providers in the component's hierarchy.
+
+**The New System:** The new model is more explicit and powerful, providing clearer data flow and eliminating "magic".
+
+*   **Reactive Data Proxies**: The `data` object of a provider is now a deep Proxy. You can now trigger reactive updates simply by direct assignment (`myProvider.data.foo = 'new value'`), and any component bound to that data will update automatically.
+*   **Intelligent Hierarchical Data Access**: The `data` object passed to bindings and formulas is now a smart proxy. It provides a unified view of the data from the entire provider hierarchy. When you read a property (`data.someValue`), the proxy intelligently searches up the component tree to find the closest provider that owns it. When you write a property using `myProvider.setData('someValue', ...)`, it intelligently finds the correct provider in the hierarchy that already owns the property and updates it there, preventing accidental name collisions and making state updates safe and predictable.
+*   **Formulas**: State providers now support formulas—functions that derive their value from other state properties (e.g., `fullName: data => `${data.firstName} ${data.lastName}``). These formulas are themselves reactive and will automatically re-calculate when their dependencies change.
+*   **Two-Way Bindings**: Two-way data bindings kept the same power as before, powered by the original config system.
+
+#### 3. Enhanced Class System
+
+*   **Automatic Static Config Merging for Mixins**: The framework's mixin system is now significantly more powerful. Previously limited to methods, mixins can now contribute to the `static config` of a class. The configs are intelligently merged with a clear order of precedence:
+    1.  The target class's own `static config` always has the highest priority.
+    2.  For conflicting configs between mixins, the mixin that appears *earlier* in the `mixins` array wins.
+    3.  Mixins on a base class take precedence over mixins on an extended class.
+*   **Granular Cloning Strategies**: The reactive config system now features `clone` and `cloneOnGet` descriptor flags, providing fine-grained control over how and when config values are cloned. This is critical for performance tuning and handling complex data types.
+
+### New Learning Content
+
+*   **New Guide: "Declarative VDOM with Effects"**: A new guide has been added to the documentation to explain the principles of the new reactivity system and demonstrate how to build components using an Effect-based approach.
+
+### Quality & Stability
+*   This release includes a comprehensive suite of new unit tests covering the Effect-based reactivity system, the `state.Provider`, and the enhanced `static config` merging. This ensures the stability and correctness of these foundational new features and helps prevent future regressions.
+
+---
+
+All changes combined in 1 commit: https://github.com/neomjs/neo/commit/2105ea95b8b498c73d9c54f6bffe8de8704dfe0d
+
+This release represents a major leap forward for the Neo.mjs framework, providing a state-of-the-art reactive programming model that is both powerful and easy to use.
+
+### Call To Action
+
+We are incredibly excited for you to explore these new capabilities.
+
+*   **Explore Effects**: Try creating your own effects to manage component logic and state.
+*   **Leverage State Providers**: Experiment with the new Proxy-based data objects and formulas in `state.Provider`.
+*   **Read the New Guide**: Check out the [Declarative VDOM with Effects guide](https://github.com/neomjs/neo/blob/dev/learn/guides/fundamentals/DeclarativeVDOMWithEffects.md) to get started with the new paradigm.
+*   **Share Your Feedback**: Your insights are invaluable. Please share your experiences and report any issues via [GitHub Issues](https://github.com/neomjs/neo/issues) or our [Slack Channel](https://join.slack.com/t/neomjs/shared_invite/zt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA).

package/.github/RELEASE_NOTES/v10.0.0-beta.6.md

@@ -0,0 +1,48 @@
+# Neo.mjs v10.0.0-beta.6 Release Notes
+
+This release represents a monumental leap forward, introducing a deeply re-architected reactivity system and a revolutionary VDOM engine that enables surgical, high-performance updates. Building on the foundation of `beta.5`, this version delivers a state-of-the-art developer experience with a new config system, synchronous batched effects, and the official debut of Functional Components.
+
+## ✨ Highlights
+
+### 🚀 Hyper-Optimized VDOM Update Engine
+
+While Neo.mjs has long used a "scoped" VDOM model, this release introduces a revolutionary **update aggregation and orchestration engine**. This new architecture dramatically enhances performance in complex, real-world scenarios (#7076, #7077).
+
+- **Centralized Orchestration:** The new **`Neo.manager.VDomUpdate`** singleton acts as a central orchestrator, intelligently merging multiple, simultaneous update requests from different components into a single, atomic transaction.
+- **Combined & Asymmetric Payloads:** Imagine a toolbar and one of its ten buttons both change state in the same event loop. The new VDOM engine can now generate a **single, minimal, asymmetric VDOM payload** containing the toolbar's structure and *only* the updated button's new content. This results in one hyper-efficient update instead of multiple, potentially conflicting ones.
+- **Key Benefits:** This new model drastically reduces worker traffic, minimizes payload size, and guarantees state integrity for all callbacks, even during complex, overlapping updates.
+
+### 🧠 Fine-Grained Reactivity & The New Config System
+
+The core of this release is a new, more powerful way to define and manage reactive state.
+
+- **`@reactive` Decorator:** We have introduced a new `@reactive` decorator (or a `_` suffix as a non-decorator alternative) to explicitly flag configs as reactive. This improves code clarity and makes the developer's intent clear.
+- **`Neo.createConfig()`:** The logic for creating reactive configs has been separated from the class system's `setupClass()`. The new `Neo.createConfig()` method allows for the creation of **named, instance-level reactive configs**, providing unparalleled flexibility for dynamic state management.
+
+### ⚡�� Synchronous Effects & Atomic Batching
+
+The effect system has been re-engineered for maximum control and performance.
+
+- **Synchronous by Default:** Effects now run synchronously by default, providing a more predictable execution flow. The `lazy: true` option is still available for cases where initial execution needs to be deferred.
+- **`EffectManager.pause()`:** The `EffectManager` can now be paused, giving developers fine-grained control over when dependency tracking is active.
+- **Atomic Batching:** The `EffectBatchManager` ensures that all updates triggered by a single, top-level operation (like `setData()`) are collected, de-duplicated, and executed in a single, atomic batch.
+
+### 💻 Functional Components & Unified VDOM Lifecycle
+
+This release officially introduces a new, modern paradigm for building UIs in Neo.mjs, supported by a unified lifecycle.
+
+- **New `VdomLifecycle` Mixin:** The core VDOM lifecycle logic has been extracted from `component.Base` into the new **`Neo.mixin.VdomLifecycle`**. This major architectural improvement allows both class-based and functional components to share the exact same robust and predictable lifecycle.
+- **Declarative UI:** Create components as pure functions using the new `defineComponent` method. Manage state effortlessly with reactive hooks like `useConfig`.
+- **Real-World Example:** The new **Email Application** (`apps/email/view/MainView.mjs`) is built entirely with functional components, serving as a comprehensive showcase of this new architecture.
+
+### 📦 Core Enhancements & Stability
+
+- **Enhanced Mixin System:** Mixins are now a first-class citizen for composing component features. They can now contribute directly to the `static config` of a class, including both reactive and non-reactive properties, which are intelligently merged with the class's own configs (#6905).
+- **Improved Update Stability:** A small but critical change to `updateVdom()` now prevents it from queuing any updates before a component is fully constructed (`isConstructed` is true). This eliminates a whole class of potential race conditions and ensures updates only happen when a component is in a valid rendering state.
+- **`Neo.gatekeep()`:** A new `Neo.gatekeep()` method has been introduced to standardize how singleton and module exports are handled, improving consistency and preventing duplicate instantiations (#7081, #7072).
+
+### 📚 New Content & Developer Experience
+
+- **Enhanced Live Previews:** The LivePreview engine has been overhauled to fully support functional components and modern JavaScript (#7069, #7073).
+- **New Framework Comparisons:** The documentation now includes new, in-depth comparison articles against other popular frameworks (like React) to better highlight the unique architectural advantages of Neo.mjs.
+- **New Tests & Learning Content:** This release is backed by a massive suite of new tests covering all aspects of the new reactivity model and VDOM engine. The learning content has also been significantly expanded.

package/.github/RELEASE_NOTES/v10.0.0.md

@@ -0,0 +1,52 @@
+### Neo.mjs v10.0.0 Stable Release Notes
+
+This release brings significant enhancements and refactorings, improving performance, reactivity, and the overall developer experience.
+
+#### Core Framework Improvements
+
+*   **Reactive Core Refactoring (`core.Observable`):**
+    *   Architectural refactoring of `core.Observable` to a fully reactive mixin (`#7090`).
+    *   **Modernized `core.Observable`:** Refactored `core.Observable` to align with the reactive config system. This involved converting the `listeners` property to a reactive `listeners_` config, eliminating manual initialization, and establishing true encapsulation using a module-scoped `Symbol` (`eventMapSymbol`) for internal event registry management. A bug in `removeListener` related to incorrect state access was also fixed. (`#7090`)
+    *   Listeners are now managed as a reactive config within `core.Observable` (`#7089`).
+*   **Effect Management System:**
+    *   **Foundational Refactoring of Effect Management:** The core reactivity system has been refactored and unified under a single `Neo.core.EffectManager` (`#7085`). This introduces a clear distinction between:
+        *   **Execution Batching (`pause()` / `resume()`):** Replaced the old `isPaused` flag with a numeric `pauseCounter` for robust, nested batching of UI updates. Effects are queued and executed only when the counter is zero.
+        *   **Dependency Tracking Suppression (`pauseTracking()` / `resumeTracking()`):** A new mechanism (`isTrackingPaused` flag) to temporarily stop active effects from collecting new dependencies, solving self-dependency issues.
+    *   The `EffectBatchManager` singleton has been completely removed, and its functionality absorbed by the enhanced `EffectManager`. This results in a more predictable, robust, and resilient reactive system.
+*   **State Management:**
+    *   **State Provider Refactoring & Deep Merging:**
+        *   Refactored `state.Provider`'s `internalSetData()` method to support intuitive deep-merging of nested objects, allowing dynamic creation of new, fully reactive data structures at runtime. This resolves inconsistent behavior and aligns with expected merge operations. (`#7099`)
+        *   **Enhanced Reactivity & Atomic Updates:** `state.Provider` now features "Reactivity Bubbling," where changes to leaf properties recursively update parent objects, correctly triggering effects on intermediate data objects. Public `setData()` and `setDataAtSameLevel()` methods are now wrapped with `Neo.batch()` (leveraging the new `EffectManager`'s batching capabilities) to ensure all reactive updates are collected, de-duplicated, and executed atomically, preventing race conditions and improving performance. A new test suite (`ProviderNestedDataConfigs.mjs`) validates this functionality.
+        *   Moved all state provider related logic (configs like `bind`, `modelData`, `stateProvider_`, `data_`, `parentComponent_`, and methods like `getStateProvider()`, `getState()`, `setState()`, `beforeGetData()`, `getConfigInstanceByNtype()`, along with lifecycle logic and two-way binding logic) from `src/component/Base.mjs` to `src/component/Abstract.mjs`. This makes state providers available to both classic class-based components and modern functional components. (`#7100`)
+*   **Component Base Classes:**
+    *   **Common Abstract Base Class:** Introduced `Neo.component.Abstract` as a new common base class for both `Neo.component.Base` (classic) and `Neo.functional.component.Base` (functional) components. This refactoring centralizes shared logic (e.g., `set()`, `destroy()`, `mountedPromise`, core configs, `DomEvents`, `Observable`, `VdomLifecycle` mixins), improving code reusability, enhancing consistency, and simplifying maintenance by removing duplicated code. (`#7089`)
+    *   Removed redundant `createBindings()` calls from `onConstructed` (`#7101`).
+
+#### Functional Components
+
+*   **VDOM Reconciliation:** Enhanced Functional Component VDOM Reconciliation (`#7086`).
+*   **Lifecycle Hook:** Introduced a new `beforeUpdate()` lifecycle method to `Neo.functional.component.Base` (`#7084`). This hook executes after all state changes from a reactive `Effect` have been processed and just before `updateVdom()`. It provides a predictable entry point for pre-render logic and allows conditionally canceling a VDOM update by returning `false`.
+*   **Functional Button Component:** Introduced a new `Neo.functional.button.Base` component (`#7087`). This component serves as a key UI element built using the functional component paradigm, demonstrating integration with the reactive VDOM system and leveraging automatic VDOM node ID generation for efficient diffing. A dedicated test suite and demo application were created.
+*   `functional.button.Base`: `beforeSetBadgePosition()`, `beforeSetIconPosition()` now use constructor access for future class extensions.
+
+#### VDOM & Rendering
+
+*   `util.vdom.TreeBuilder`: Improvements to `buildTree()`: Refactored `getVdomTree` and `getVnodeTree` into a single, DRY method (`#7098`).
+*   `util.VDom`: `syncVdomIds()` enhanced for future-proofing and improved filtering.
+*   `manager.VDomUpdate`: Significantly enhanced JSDoc comments and method order/cleanup.
+
+#### Other Enhancements & Fixes
+
+*   **Dependencies:** Updated FontAwesome to v7.
+*   **Examples Website:** Fixed flakiness on Safari (`#7102`).
+*   **Tests:** All 770 unit tests now pass successfully, including a significant number of new tests added since beta.6.
+*   `form.field.Text`: `onInputValueChange()` intent made clearer.
+*   `Portal.view.ViewportController`: Cube-layout timing adjustments.
+*   `core.core.EffectManager`: Optimized `Neo.batch` usage.
+*   Removed obsolete `onNeoConfigChange()` calls from tests.
+*   Updated `test/siesta/tests/vdom/layout/Cube.mjs` to match current `VdomHelper.create()` signature.
+
+#### Documentation Updates
+
+*   The `learn/guides/datahandling/StateProviders.md` guide has been updated to accurately describe the new deep-merge behavior of state providers.
+*   Code examples in the `learn/blog/v10-deep-dive-state-provider.md` blog post have been updated to demonstrate the intuitive API usage.