Neo.mjs v10.9.0 Release Notes

This release marks a significant milestone in our journey towards a fully AI-native development environment. The primary focus of v10.9.0 is the extension of the AI Knowledge Base to support workspaces, fulfilling the vision of providing deep, semantic understanding of not just the framework, but of your own applications.

Alongside this flagship feature, this release includes a suite of improvements to our internal AI agent processes and documentation standards, making our development workflow more robust and transparent.

✨ Highlights

🚀 AI Knowledge Base for Workspaces

The AI Knowledge Base is no longer confined to the neo repository. It is now fully integrated into the standard workspace workflow, enabling any project created with npx neo-app to have its own local, context-aware knowledge base. This empowers AI agents to understand your specific application code, leading to more accurate, relevant, and helpful contributions (#7245).

• Workspace-Aware Tooling: The create-app script now automatically sets up the necessary files (AGENTS.md, AI_QUICK_START.md) and environment configuration for the AI knowledge base to work out-of-the-box in new workspaces.
• Portable AI Scripts: The core AI scripts (createKnowledgeBase, embedKnowledgeBase, queryKnowledgeBase) have been refactored to be environment-aware, seamlessly operating within either the core neo repo or a generated workspace.
• Updated Onboarding: The AI_QUICK_START.md guide has been updated to provide clear setup instructions for both framework contributors and application developers working in a workspace (#7247).

🧠 Enhanced Knowledge Base Content & Discovery

The quality and accessibility of the knowledge base have been significantly improved through better content integration and smarter querying.

• Release Notes in KB: All historical release notes are now embedded into the knowledge base, allowing developers and agents to query for information about when features were introduced or changed (#7241).
• Smarter Query Scoring: The query algorithm has been refined to prioritize evergreen content like guides over historical blog posts (#7243) and to provide more accurate results for version-specific queries (#7242).
• Optimized Structure File: The initial structure file (structure.json) used by the agent has been replaced with a new, highly efficient class-hierarchy.yaml file. This dramatically reduces the token footprint while still providing a complete map of the framework's class inheritance, improving the agent's startup performance and reliability (#7246).

🤖 Agent & Contributor Process Automation

This release formalizes and automates key aspects of our development and ticketing workflow, making the process more robust and transparent for both AI and human contributors.

• Hybrid Ticket Strategy: A new, formal ticket strategy has been documented in TICKET_STRATEGY.md, defining a clear lifecycle for tasks from creation to archival (#7239).
• "Ticket-First" Mandate: The agent's core workflow has been updated to enforce a strict "ticket-first" mandate, ensuring every modification to the repository is tracked from its inception (#7240, #7248).

📚 Documentation & Code Quality

• New Neo.component.Image: A new Image component has been added, providing a reactive, class-based interface for the <img> tag. This serves as a foundational component for image handling and lazy loading patterns (#7244).
• Formalized JSDoc Standards: The project's CODING_GUIDELINES.md have been updated with explicit standards for documenting reactive configs using the @reactive tag, ensuring consistency across the codebase (#7237).
• Enhanced Example Documentation: The Helix component example has been updated with rich, query-driven JSDoc comments, making it a better learning resource and a prime example of our new documentation standards (#7236).

All changes in 1 commit: 429a98c

Neo.mjs v10.8.0 Release Notes

Summary

Version 10.8.0 is a significant minor release focused on enhancing the AI-Native development experience. This version formalizes a more advanced, query-driven documentation strategy and introduces a new blog post detailing the philosophy and architecture behind Neo.mjs's AI-first approach.

Key Enhancements

1. Refined AI Agent Workflow & Query Tool

The AI agent guidelines (AGENTS.md) and the underlying query engine have been significantly enhanced to improve the entire AI-native development workflow.

• Advanced Query Filtering: The knowledge base query script (queryKnowledgeBase.mjs) was refactored to use commander and now includes a powerful --type flag. This allows developers and AI agents to filter search results by content type (all, blog, guide, src, example), making it much easier to find specific kinds of information.
• Query-Driven Documentation: The agent protocol was updated with the "Contributing Queryable, Intent-Driven Comments" strategy. This requires agents to enrich source code with conceptual keywords, @summary tags, and @see links, turning our codebase into a more discoverable knowledge base.
• Structural Improvements: The AGENTS.md document flow was improved by relocating key sections and fixing cross-references for better readability.
• Regression Testing: The agent guidelines now include a prompt to create regression tests for all bug fixes, with a direct link to the UnitTestingWithSiesta.md guide to ensure issues, once solved, stay solved.

This change transforms the AI from a simple code generator into a true contributor to the project's long-term health and maintainability.

2. Enhanced StateProvider Example

As the first implementation of our new documentation strategy, the advanced StateProvider example (examples/stateProvider/advanced/) has been updated with comprehensive, intent-driven JSDoc comments. This makes the example a much clearer, self-documenting resource for understanding hierarchical state management in Neo.mjs.

3. New Blog Post: "AI-Native, Not AI-Assisted"

A new in-depth article has been added to our blog, which covers:

• The core philosophy behind building an AI-Native framework.
• A technical deep-dive into our local-first, Retrieval-Augmented Generation (RAG) system.
• A comparison of Neo.mjs's approach with other industry implementations like Angular's MCP.
• The future roadmap for extending these AI capabilities to user-created workspaces.

This article is now accessible via the neo website or on medium:
https://tobiasuhlig.medium.com/ai-native-not-ai-assisted-a-platform-that-answers-your-questions-0c08f5a336ae?source=friends_link&sk=45cc238e4f342672d3eb3244136b7770

All changes in 1 commit: 009065f

Neo.mjs v10.7.0 Release Notes

Version 10.7.0 massively enhances the AI-Native Developer Experience introduced in v10.6.0, making it more powerful, scalable, and deeply integrated into the development workflow. This release also delivers substantial new learning content to accelerate developer onboarding.

🚀 Highlights

• Major AI Knowledge Base Upgrade: Building on the foundation from v10.6.0, the AI Knowledge Base has been re-architected for scalability and enriched with more content. It now uses a streaming pipeline for memory-efficient processing and includes all blog posts, making it a more comprehensive and performant resource.
• Formalized AI-Driven Development: The new AGENTS.md file provides a comprehensive operational manual for AI agents, formalizing the process for AI-driven development within the repository.
• Extensive New Learning Content: This version adds three major new guides covering Styling and Theming, Unit Testing, and Application Routing, plus a new blog post on the framework's AI-native architecture.

✨ New Features

• AI Agent Guidelines (#7220, #7221): A new AGENTS.md file has been created to provide a comprehensive operational manual for AI agents working within the repository.
• New Guide: Styling and Theming (#6778): A new, in-depth guide covering all aspects of styling and theming in Neo.mjs.
• New Guide: Unit Testing with Siesta (#7222): A new guide providing a step-by-step introduction to the unit testing workflow.
• New Tutorial: Multi-Page App Routing (#7223): A new tutorial that walks developers through building a simple single-page application with client-side routing.
• New Blog Post (#7226, d7492da61): Added the blog post "The UI Revolution: How JSON Blueprints & Shared Workers Power Next-Gen AI Interfaces" to the repository.

💡 Enhancements

• AI Knowledge Base:
  • Blog Integration (#7216): The knowledge base now includes content from all blog posts.
  • Streaming for Memory Efficiency (#7215): The knowledge base generation scripts now use a streaming pipeline, significantly lowering memory footprint.
  • Query Scoring Refactor (#7218): The query scoring algorithm has been refactored for improved performance and relevance.
  • Query Performance (0a667b35d): Query script performance has been drastically improved by moving score adjustment logic to the embedding phase.
  • Content Filtering (#7217): The learn/comparisons folder is now excluded from the knowledge base.
• AI Tooling & Developer Experience:
  • Intent-Driven JSDoc Comments (#7219): Core AI scripts have been enhanced with intent-driven JSDoc comments.
• README.md (d7e3c6ebe): The main README now includes a section on the "AI-Native by Design" philosophy.

---

Try the AI-Native Experience

With the significant enhancements to the AI Knowledge Base and the new AGENTS.md guidelines, the Neo.mjs repository is now fully equipped for AI-driven development. We encourage you to try it out using tools like Gemini CLI or your own custom agents.

Get started in minutes by following our AI Quick Start Guide.

All changes in 1 commit: 49eeda7

Neo.mjs v10.6.0 Release Notes

Highlights

This release introduces a powerful new AI Knowledge Base for the Neo.mjs repository, significantly improves the Dashboard Drag & Drop functionality, and adds a new Window Management permission request.

New: AI Knowledge Base

We are excited to introduce a local AI Knowledge Base, a new feature that allows developers to interact with the Neo.mjs codebase and documentation in a conversational way. This is especially powerful for those using AI assistants like Gemini CLI or building custom agents.

Instead of manually searching through files, you can now ask questions directly and get answers based on the framework's source code, documentation, and blog posts. This can dramatically speed up development and learning.

Key features include:

• Conversational Code Queries: Ask questions about classes, methods, and configurations.
• Comprehensive Content: The knowledge base includes the framework's source code, JSDoc, markdown files and the Neo.mjs blog posts.
• Local & Private: Your data stays on your machine. It runs locally, using a local vector database (ChromaDB) and your own GEMINI_API_KEY.

This is the first iteration of the AI Knowledge Base, and we are excited to see how you use it. For more details on the implementation, see issue #7214.

To get started, please follow the instructions in the .github/AI_QUICK_START.md guide.

Dashboard Drag & Drop

• The Dashboard Drag & Drop functionality has been significantly improved with the introduction of drag boundaries and sort zones.
• A new dragBoundaryEntry event has been added.
• The onDragMove() method in main.addon.DragDrop now passes the drag element's rect to the app worker.
• The dashboard.Container now supports allowOverdrag.
• A regression bug in draggable.dashboard.SortZone: moveTo() has been fixed.

Window Management

• A new permission request for window management has been implemented, allowing for more control over windowing behavior.

Other Changes & Fixes

• Dependencies have been updated.
• The README has been updated.
• The portal app's blog.json has been updated.

All changes in 1 commit: ff507b3

Neo.mjs v10.5.4 Release Notes

• Added the new blog post to the Portal App (neo website)
• Friends link: https://tobiasuhlig.medium.com/benchmarking-frontends-in-2025-f6bbf43b7721?source=friends_link&sk=af0f2c6745a7ca4993bc0ae60ad0ebb4

Neo.mjs v10.5.3 Release Notes

Bug Fixes

• grid.Container: Corrected the calculation for the aria-rowcount attribute. The count was previously store.count + 2, and has been adjusted to store.count + 1 to accurately reflect the number of data rows plus the single header row, improving accessibility for screen readers.

Neo.mjs v10.5.2 Release Notes

Features

• grid.Container: Added the aria-colcount attribute to the grid's wrapper element to enhance accessibility.
• This attribute dynamically updates with the number of columns, ensuring screen readers can accurately announce the grid's structure.

Enhancements

• grid.Container: The updateColCount() method now includes a silent parameter. This allows for updating the column count without triggering an immediate DOM update, optimizing performance in scenarios where multiple changes occur in sequence.
• examples.grid.bigData.ControlsContainer: To improve user feedback, a loading mask is now displayed during the initial data filtering process in the Big Data grid example.

Bug Fixes

• data.Store: Fixed an issue where the isLoaded flag was not set to true when records were added to the store via
  the add() method. This ensures that the load event is fired correctly, even when the store is populated manually
  instead of through assigning data or autoLoad.

Neo.mjs v10.5.1 Release Notes

Bug Fixes

table.Body

• Fixed a JavaScript error that occurred when filtering a table's store. A previous change modified the method signature of onStoreLoad() to expect a destructured object containing the store's items. However, the onStoreFilter() method was not updated to reflect this change and continued to call onStoreLoad() without the required arguments.
• onStoreFilter() now correctly passes the store's data to onStoreLoad(), resolving the error and ensuring that table filtering works as expected.

Neo.mjs v10.5.0 Release Notes

Major Performance Enhancements for Grids and Data Handling

This release introduces a groundbreaking set of performance optimizations for Neo.data.Store and Neo.grid.Container, fundamentally transforming how large datasets are handled within Neo.mjs applications. These enhancements dramatically reduce initial load times, improve UI responsiveness, and resolve critical VDom reconciliation issues, making it feasible to work with millions of data points with unprecedented fluidity.

Key Highlights:

• Lazy Record Instantiation (GET-driven approach):

  • Neo.data.Store now defers the creation of Neo.data.Record instances. Raw data objects are stored directly, and Record instances are only created on-demand when an item is explicitly accessed (e.g., via store.get(), store.getAt(), or during VDom rendering of visible rows).
  • Impact: This eliminates the massive upfront cost of instantiating millions of Record objects, leading to up to 97% reduction in initial data processing time for large datasets.

• Configurable Data Chunking for UI Responsiveness:

  • Introduced an initialChunkSize config in Neo.data.Store (default 0). When enabled, Store.add() processes data in chunks, significantly mitigating UI freezes during synchronous loading of extremely large datasets (e.g., 1,000,000+ rows).
  • Impact: Provides a smoother perceived user experience during initial data loads, even for datasets that would otherwise cause multi-second UI blocks.

• Robust Component ID Management for VDom Stability:

  • Resolved critical VDom reconciliation errors (e.g., RangeError, infinite loops) that could occur with component columns when chunking was active. Neo.grid.column.Component now intelligently generates unique IDs based on the store's chunking state, ensuring VDom stability.
  • Impact: Eliminates a major source of instability and crashes when using component columns with large, dynamically loaded datasets.

• Automated Component Instance Cleanup:

  • Enhanced Neo.grid.Body with sophisticated component instance management. Components are now automatically destroyed when the grid body is destroyed, the store is cleared, the store changes, or when they scroll out of view after a chunked load.
  • Impact: Reduces memory overhead and improves long-term performance by preventing the accumulation of unused component instances.

• GPU-Accelerated Vertical Scrolling (translate3d):

  • Grid rows now utilize transform: translate3d(0px, Ypx, 0px) for vertical positioning. This hints to the browser to promote rows to their own composite layers, offloading rendering to the GPU.
  • Impact: Leads to noticeably smoother and more fluid vertical scrolling, especially during rapid movements through large grids.

Other Enhancements:

• ComboBox Initial Display Fix: Resolved an issue where Neo.form.field.ComboBox instances would appear blank on initial load when backed by lazily instantiated stores. The updateInputValueFromValue method now correctly displays values from raw data or Record instances.
• Enhanced BigData Grid Example: The examples/grid/bigData demo has been updated to include control options for up to 200 columns, allowing for testing with up to 20,000,000 cells. This provides a more extreme and comprehensive benchmark for grid performance.

These collective improvements mark a significant leap forward in Neo.mjs's capability to handle and display massive amounts of data with high performance and a superior user experience.

---

Performance Benchmarks (from examples/grid/bigData):

Scenario	Before (Eager Instantiation)	After (Lazy Instantiation, with chunking)	After (Lazy Instantiation, no chunking)
1,000 rows, 50 columns	49ms (Record creation)	2ms (Data gen + add)	2ms (Data gen + add)
50,000 rows, 50 columns	2391ms (Record creation)	1252ms (Data gen + add)	93ms (Data gen + add)
50,000 rows, 100 columns	4377ms (Record creation)	1289ms (Data gen + add)	95ms (Data gen + add)
100,000 rows, 50 columns	N/A (too slow)	1299ms (Data gen + add)	156ms (Data gen + add)
100,000 rows, 200 columns	N/A (too slow)	1427ms (Data gen + add)	174ms (Data gen + add)

Note: "Record creation" refers to the time taken for Neo.data.Record instantiation. "Data gen + add" refers to the time taken to generate raw data and add it to the store's collection.

Important Note on Chunking:
The introduction of lazy record instantiation significantly reduces the need for chunking in most common use cases, as the initial data loading is now extremely fast even for large datasets. However, Neo.mjs still optionally supports data chunking via the initialChunkSize config for scenarios involving truly massive synchronous data additions where mitigating UI freezes is paramount.

Try it out by yourself:
https://neomjs.com/examples/grid/bigData/index.html
https://neomjs.com/dist/production/examples/grid/bigData/index.html

All changes combined into 1 Commit: 5d4760b

Neo.mjs v10.4.1 Release Notes

Highlights

This patch release polishes the "instant preview" feature for grids introduced in v10.4.0, ensuring the grid's scrollbar and accessibility properties are correctly sized from the very first paint when loading large datasets. The non-buffered table.Body also receives a major performance boost for clearing data.

Enhancements & Bug Fixes

1. Polished "Instant Preview" for Large Datasets in Grids

The chunked loading mechanism for stores and grids has been refined. When adding a large dataset, the initial load event now carries the final total record count. The grid.Container uses this information immediately to set the correct aria-rowcount and to size the vertical scrollbar accurately, preventing layout shifts and providing a more stable and accessible user experience from the very first render.

2. Standardized Internal Store load Event

To support the "instant preview" refinements, the data.Store load event payload has been standardized internally. It now consistently uses an object containing an items property (e.g., {items: [...]}). Framework components have been updated to use this new signature.

3. Performance Fast Path for table.Body

The non-buffered table.Body is now significantly faster when clearing its data. It uses the same "fast path" optimization as grid.Body, directly clearing the DOM instead of processing a large and unnecessary VDOM diff when an empty dataset is loaded. This aligns the performance of the two components.