[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"similar-neomjs--neo":3,"tool-neomjs--neo":64},[4,17,27,35,48,56],{"id":5,"name":6,"github_repo":7,"description_zh":8,"stars":9,"difficulty_score":10,"last_commit_at":11,"category_tags":12,"status":16},3808,"stable-diffusion-webui","AUTOMATIC1111\u002Fstable-diffusion-webui","stable-diffusion-webui 是一个基于 Gradio 构建的网页版操作界面，旨在让用户能够轻松地在本地运行和使用强大的 Stable Diffusion 图像生成模型。它解决了原始模型依赖命令行、操作门槛高且功能分散的痛点，将复杂的 AI 绘图流程整合进一个直观易用的图形化平台。\n\n无论是希望快速上手的普通创作者、需要精细控制画面细节的设计师，还是想要深入探索模型潜力的开发者与研究人员，都能从中获益。其核心亮点在于极高的功能丰富度：不仅支持文生图、图生图、局部重绘（Inpainting）和外绘（Outpainting）等基础模式，还独创了注意力机制调整、提示词矩阵、负向提示词以及“高清修复”等高级功能。此外，它内置了 GFPGAN 和 CodeFormer 等人脸修复工具，支持多种神经网络放大算法，并允许用户通过插件系统无限扩展能力。即使是显存有限的设备，stable-diffusion-webui 也提供了相应的优化选项，让高质量的 AI 艺术创作变得触手可及。",162132,3,"2026-04-05T11:01:52",[13,14,15],"开发框架","图像","Agent","ready",{"id":18,"name":19,"github_repo":20,"description_zh":21,"stars":22,"difficulty_score":23,"last_commit_at":24,"category_tags":25,"status":16},1381,"everything-claude-code","affaan-m\u002Feverything-claude-code","everything-claude-code 是一套专为 AI 编程助手（如 Claude Code、Codex、Cursor 等）打造的高性能优化系统。它不仅仅是一组配置文件，而是一个经过长期实战打磨的完整框架，旨在解决 AI 代理在实际开发中面临的效率低下、记忆丢失、安全隐患及缺乏持续学习能力等核心痛点。\n\n通过引入技能模块化、直觉增强、记忆持久化机制以及内置的安全扫描功能，everything-claude-code 能显著提升 AI 在复杂任务中的表现，帮助开发者构建更稳定、更智能的生产级 AI 代理。其独特的“研究优先”开发理念和针对 Token 消耗的优化策略，使得模型响应更快、成本更低，同时有效防御潜在的攻击向量。\n\n这套工具特别适合软件开发者、AI 研究人员以及希望深度定制 AI 工作流的技术团队使用。无论您是在构建大型代码库，还是需要 AI 协助进行安全审计与自动化测试，everything-claude-code 都能提供强大的底层支持。作为一个曾荣获 Anthropic 黑客大奖的开源项目，它融合了多语言支持与丰富的实战钩子（hooks），让 AI 真正成长为懂上",138956,2,"2026-04-05T11:33:21",[13,15,26],"语言模型",{"id":28,"name":29,"github_repo":30,"description_zh":31,"stars":32,"difficulty_score":23,"last_commit_at":33,"category_tags":34,"status":16},2271,"ComfyUI","Comfy-Org\u002FComfyUI","ComfyUI 是一款功能强大且高度模块化的视觉 AI 引擎，专为设计和执行复杂的 Stable Diffusion 图像生成流程而打造。它摒弃了传统的代码编写模式，采用直观的节点式流程图界面，让用户通过连接不同的功能模块即可构建个性化的生成管线。\n\n这一设计巧妙解决了高级 AI 绘图工作流配置复杂、灵活性不足的痛点。用户无需具备编程背景，也能自由组合模型、调整参数并实时预览效果，轻松实现从基础文生图到多步骤高清修复等各类复杂任务。ComfyUI 拥有极佳的兼容性，不仅支持 Windows、macOS 和 Linux 全平台，还广泛适配 NVIDIA、AMD、Intel 及苹果 Silicon 等多种硬件架构，并率先支持 SDXL、Flux、SD3 等前沿模型。\n\n无论是希望深入探索算法潜力的研究人员和开发者，还是追求极致创作自由度的设计师与资深 AI 绘画爱好者，ComfyUI 都能提供强大的支持。其独特的模块化架构允许社区不断扩展新功能，使其成为当前最灵活、生态最丰富的开源扩散模型工具之一，帮助用户将创意高效转化为现实。",107662,"2026-04-03T11:11:01",[13,14,15],{"id":36,"name":37,"github_repo":38,"description_zh":39,"stars":40,"difficulty_score":23,"last_commit_at":41,"category_tags":42,"status":16},2268,"ML-For-Beginners","microsoft\u002FML-For-Beginners","ML-For-Beginners 是由微软推出的一套系统化机器学习入门课程，旨在帮助零基础用户轻松掌握经典机器学习知识。这套课程将学习路径规划为 12 周，包含 26 节精炼课程和 52 道配套测验，内容涵盖从基础概念到实际应用的完整流程，有效解决了初学者面对庞大知识体系时无从下手、缺乏结构化指导的痛点。\n\n无论是希望转型的开发者、需要补充算法背景的研究人员，还是对人工智能充满好奇的普通爱好者，都能从中受益。课程不仅提供了清晰的理论讲解，还强调动手实践，让用户在循序渐进中建立扎实的技能基础。其独特的亮点在于强大的多语言支持，通过自动化机制提供了包括简体中文在内的 50 多种语言版本，极大地降低了全球不同背景用户的学习门槛。此外，项目采用开源协作模式，社区活跃且内容持续更新，确保学习者能获取前沿且准确的技术资讯。如果你正寻找一条清晰、友好且专业的机器学习入门之路，ML-For-Beginners 将是理想的起点。",84991,"2026-04-05T10:45:23",[14,43,44,45,15,46,26,13,47],"数据工具","视频","插件","其他","音频",{"id":49,"name":50,"github_repo":51,"description_zh":52,"stars":53,"difficulty_score":10,"last_commit_at":54,"category_tags":55,"status":16},3128,"ragflow","infiniflow\u002Fragflow","RAGFlow 是一款领先的开源检索增强生成（RAG）引擎，旨在为大语言模型构建更精准、可靠的上下文层。它巧妙地将前沿的 RAG 技术与智能体（Agent）能力相结合，不仅支持从各类文档中高效提取知识，还能让模型基于这些知识进行逻辑推理和任务执行。\n\n在大模型应用中，幻觉问题和知识滞后是常见痛点。RAGFlow 通过深度解析复杂文档结构（如表格、图表及混合排版），显著提升了信息检索的准确度，从而有效减少模型“胡编乱造”的现象，确保回答既有据可依又具备时效性。其内置的智能体机制更进一步，使系统不仅能回答问题，还能自主规划步骤解决复杂问题。\n\n这款工具特别适合开发者、企业技术团队以及 AI 研究人员使用。无论是希望快速搭建私有知识库问答系统，还是致力于探索大模型在垂直领域落地的创新者，都能从中受益。RAGFlow 提供了可视化的工作流编排界面和灵活的 API 接口，既降低了非算法背景用户的上手门槛，也满足了专业开发者对系统深度定制的需求。作为基于 Apache 2.0 协议开源的项目，它正成为连接通用大模型与行业专有知识之间的重要桥梁。",77062,"2026-04-04T04:44:48",[15,14,13,26,46],{"id":57,"name":58,"github_repo":59,"description_zh":60,"stars":61,"difficulty_score":10,"last_commit_at":62,"category_tags":63,"status":16},2181,"OpenHands","OpenHands\u002FOpenHands","OpenHands 是一个专注于 AI 驱动开发的开源平台，旨在让智能体（Agent）像人类开发者一样理解、编写和调试代码。它解决了传统编程中重复性劳动多、环境配置复杂以及人机协作效率低等痛点，通过自动化流程显著提升开发速度。\n\n无论是希望提升编码效率的软件工程师、探索智能体技术的研究人员，还是需要快速原型验证的技术团队，都能从中受益。OpenHands 提供了灵活多样的使用方式：既可以通过命令行（CLI）或本地图形界面在个人电脑上轻松上手，体验类似 Devin 的流畅交互；也能利用其强大的 Python SDK 自定义智能体逻辑，甚至在云端大规模部署上千个智能体并行工作。\n\n其核心技术亮点在于模块化的软件智能体 SDK，这不仅构成了平台的引擎，还支持高度可组合的开发模式。此外，OpenHands 在 SWE-bench 基准测试中取得了 77.6% 的优异成绩，证明了其解决真实世界软件工程问题的能力。平台还具备完善的企业级功能，支持与 Slack、Jira 等工具集成，并提供细粒度的权限管理，适合从个人开发者到大型企业的各类用户场景。",70612,"2026-04-05T11:12:22",[26,15,13,45],{"id":65,"github_repo":66,"name":67,"description_en":68,"description_zh":69,"ai_summary_zh":70,"readme_en":71,"readme_zh":72,"quickstart_zh":73,"use_case_zh":74,"hero_image_url":75,"owner_login":76,"owner_name":77,"owner_avatar_url":78,"owner_bio":79,"owner_company":80,"owner_location":80,"owner_email":80,"owner_twitter":80,"owner_website":81,"owner_url":82,"languages":83,"stars":96,"forks":97,"last_commit_at":98,"license":99,"difficulty_score":100,"env_os":101,"env_gpu":102,"env_ram":102,"env_deps":103,"category_tags":106,"github_topics":107,"view_count":10,"oss_zip_url":80,"oss_zip_packed_at":80,"status":16,"created_at":128,"updated_at":129,"faqs":130,"releases":168},1009,"neomjs\u002Fneo","neo","The Application Engine for the AI Era. A multi-threaded, AI-native runtime with a persistent Scene Graph, enabling AI agents to introspect and mutate the living application structure in real-time.","Neo 是一个专为 AI 时代打造的应用引擎，它提供多线程、AI 原生的运行时环境，让 Web 应用像桌面软件一样流畅稳定。通过持久化的场景图技术，Neo 将 UI 组件视为可长期存在的对象（而非临时渲染结果），使 AI 代理能实时“观察”并动态调整应用结构，实现人机协作开发。\n\n它解决了传统 Web 框架的痛点：复杂逻辑或多窗口操作时容易卡顿，AI 集成困难。例如，金融交易平台需处理每秒上万次数据更新，或跨屏幕工作空间需无缝同步，Neo 的 Off-Main-Thread 架构确保主界面始终响应迅速，避免卡顿。\n\nNeo 主要面向开发者，尤其是企业级应用团队——如果你在构建高频交易系统、多窗口控制室、AI 驱动的智能界面（如可被 AI 实时修改布局的仪表盘），或需要桌面级性能的单页应用，它能显著提升开发效率和用户体验。但普通用户或简单网站开发者更适合用 Next.js 等工具。\n\n技术亮点在于多线程设计、持久化对象模型和 AI 原生支持：AI 代理可直接参与运行时结构变异，无需重启应用。虽然学习曲线略陡（需理解 Worker 模型），但对于追求高性能与 AI 融合的复杂项目，Neo ","Neo 是一个专为 AI 时代打造的应用引擎，它提供多线程、AI 原生的运行时环境，让 Web 应用像桌面软件一样流畅稳定。通过持久化的场景图技术，Neo 将 UI 组件视为可长期存在的对象（而非临时渲染结果），使 AI 代理能实时“观察”并动态调整应用结构，实现人机协作开发。\n\n它解决了传统 Web 框架的痛点：复杂逻辑或多窗口操作时容易卡顿，AI 集成困难。例如，金融交易平台需处理每秒上万次数据更新，或跨屏幕工作空间需无缝同步，Neo 的 Off-Main-Thread 架构确保主界面始终响应迅速，避免卡顿。\n\nNeo 主要面向开发者，尤其是企业级应用团队——如果你在构建高频交易系统、多窗口控制室、AI 驱动的智能界面（如可被 AI 实时修改布局的仪表盘），或需要桌面级性能的单页应用，它能显著提升开发效率和用户体验。但普通用户或简单网站开发者更适合用 Next.js 等工具。\n\n技术亮点在于多线程设计、持久化对象模型和 AI 原生支持：AI 代理可直接参与运行时结构变异，无需重启应用。虽然学习曲线略陡（需理解 Worker 模型），但对于追求高性能与 AI 融合的复杂项目，Neo 提供了坚实基础。","\u003Cp align=\"center\">\n \u003Cimg height=\"100\"src=\"https:\u002F\u002Fraw.githubusercontent.com\u002Fneomjs\u002Fpages\u002Fmain\u002Fresources_pub\u002Fimages\u002Flogo\u002Fneo_logo_text_primary.svg\" alt=\"Neo.mjs Logo\">\n\u003C\u002Fp>\n\u003C\u002Fbr>\n\u003Cp align=\"center\">\n \u003Ca href=\"https:\u002F\u002Fnpmcharts.com\u002Fcompare\u002Fneo.mjs?minimal=true\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fdm\u002Fneo.mjs.svg?label=Downloads\" alt=\"Downloads\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fneo.mjs\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fv\u002Fneo.mjs.svg?logo=npm\" alt=\"Version\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fneo.mjs\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fl\u002Fneo.mjs.svg?label=License\" alt=\"License\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fjoin.slack.com\u002Ft\u002Fneomjs\u002Fshared_invite\u002Fzt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FSlack-Neo.mjs-brightgreen.svg?logo=slack\" alt=\"Join the Slack channel\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fdiscord.gg\u002F6p8paPq\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fdiscord\u002F656620537514164249?label=Discord&logo=discord&logoColor=white\" alt=\"Discord Chat\">\u003C\u002Fa>\n \u003Ca href=\".\u002FCONTRIBUTING.md\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FPRs-welcome-green.svg?logo=GitHub&logoColor=white\" alt=\"PRs Welcome\">\u003C\u002Fa>\n\u003C\u002Fp>\n\n# The Application Engine for the AI Era\n🚀 **True Multithreading Meets Context Engineering — Build Desktop-Class UIs with an AI Co-Developer.**\n\n> **⚡ The Mental Model:**\n> **Neo.mjs is a multi-threaded application runtime where UI components are persistent objects—not ephemeral render results.**\n> This architectural shift enables desktop-class performance, multi-window orchestration, and AI-driven runtime mutation that traditional frameworks cannot achieve.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n💻 ***Neo.mjs is not a framework; it is an Application Engine for the web. Just as Unreal Engine provides a complete runtime and toolchain for games, Neo.mjs provides a multi-threaded runtime and AI-native toolchain for enterprise applications.***\n\nImagine web applications that never jank, no matter how complex the logic, how many real-time updates they handle, or how many browser windows they span. Neo.mjs is engineered from the ground up to deliver **desktop-like fluidity and scalability**. **While it excels for Single Page Apps (SPAs), Neo.mjs is simply the best option for browser-based multi-window applications**, operating fundamentally different from traditional frameworks.\n\nBy leveraging a **pioneering Off-Main-Thread (OMT) architecture**, Neo.mjs ensures your UI remains butter-smooth. The main thread is kept free for one purpose: **flawless user interactions and seamless DOM updates.**\n\nBut performance is only half the story. With v11, Neo.mjs becomes the world's first **AI-native** frontend platform, designed to be developed *with* AI agents as first-class partners in your workflow.\n\n\u003Cp align=\"center\">\n \u003Ca href=\"https:\u002F\u002Fyoutu.be\u002FpYfM28Pz6_0\">\u003Cimg height=\"316px\" width=\"400px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_05ee37717533.png\" alt=\"Neo.mjs Performance Demo 1 (YouTube Video)\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fyoutu.be\u002FaEA5333WiWY\">\u003Cimg height=\"316px\" width=\"400px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_3e6f48ce24c5.png\" alt=\"Neo.mjs Performance Demo 2 (YouTube Video)\">\u003C\u002Fa>\n\u003C\u002Fp>\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🎯 Is Neo.mjs Right for You?\n\n**Neo.mjs is an Application Engine, not a website builder.**\n*It is a mature, enterprise-grade platform with over 130,000 lines of production-ready code.*\n\n✅ **Perfect For:**\n* **Financial & Trading Platforms:** processing 10k+ ticks\u002Fsec without UI freeze.\n* **Multi-Window Workspaces:** IDEs, Control Rooms, and Dashboards that span multiple screens.\n* **AI-Native Interfaces:** Apps where the UI structure must be mutable by AI agents at runtime.\n* **Enterprise SPAs:** Complex logic that demands the stability of a desktop application.\n\n❌ **Not Designed For:**\n* Static content sites or simple blogs (Use Astro\u002FNext.js).\n* Teams looking for \"React with a different syntax.\"\n* Developers unwilling to embrace the Actor Model (Workers).\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🚀 The AI-Native Development Platform\n\nNeo.mjs v11 introduces a revolutionary approach to software development: **Context Engineering**. We've moved beyond simple \"AI-assisted\" coding to create a truly **AI-native** platform where AI agents are deeply integrated partners in the development process. This is made possible by a suite of dedicated **Model Context Protocol (MCP) servers** that give agents the context they need to understand, build, and reason about your code.\n\nThis isn't just about generating code; it's about creating a self-aware development environment that accelerates velocity, improves quality, and enables a new level of human-AI collaboration.\n\n\u003Cp align=\"center\">\n \u003Cimg width=\"800px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_baceab19886b.png\" alt=\"Context Engineering Done Right\" class=\"blog-image\">\n\u003C\u002Fp>\n\n1. **🧠 The Knowledge Base Server**: Gives agents a deep, semantic understanding of your project. Powered by ChromaDB and Gemini embeddings, it allows agents to perform semantic searches across your entire codebase, documentation, and historical tickets. An agent can ask, \"How does VDOM diffing work?\" and get the exact source files and architectural guides relevant to the *currently checked-out version*.\n * **[📘 Read the Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FKnowledgeBase.md)**\n\n2. **💾 The Memory Core Server**: Provides agents with persistent, long-term memory. Every interaction—prompt, thought process, and response is stored, allowing the agent to learn from experience, recall past decisions, and maintain context across multiple sessions. This transforms the agent from a stateless tool into a true collaborator that grows with your project.\n * **[📘 Read the Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FMemoryCore.md)**\n\n3. **🤖 The GitHub Workflow Server**: Closes the loop by enabling agents to participate directly in your project's lifecycle. It provides tools for autonomous PR reviews, issue management, and bi-directional synchronization of GitHub issues into a local, queryable set of markdown files. This removes the human bottleneck in code review and project management.\n * **[📘 Read the Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FGitHubWorkflow.md)**\n\n4. **⚡️ The Agent Runtime**: Empower your agents to act as autonomous developers. Instead of passively asking for information, agents can write and execute complex scripts using the **Neo.mjs AI SDK**. This enables advanced workflows like self-healing code, automated refactoring, and data migration—running locally at machine speed.\n * **[📘 Read the Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FCodeExecution.md)**\n\n### Why an Engine Architecture Matters for AI\nAI agents are \"blind\" in traditional compiled frameworks (React, Svelte) because the code they write (JSX\u002FTemplates) is destroyed by the build step—the runtime reality (DOM nodes) looks nothing like the source.\n\n**In Neo.mjs, the map IS the territory.** Because components are persistent objects in the App Worker (not ephemeral DOM nodes), the AI can query their state, methods, and inheritance chain at any time. It's like inspecting a running game character in Unreal Engine, rather than parsing the pixels on the screen. The AI sees exactly what the engine sees, enabling it to reason about state, inheritance, and topology with perfect accuracy. Furthermore, the **Neural Link** allows agents to query the runtime for the **Ground Truth**, enabling them to verify reality and solve complex, runtime-dependent problems that static analysis cannot touch.\n\nThis powerful tooling, co-created with AI agents, enabled us to ship **388 architectural enhancements in just 6 weeks**. This order-of-magnitude increase in velocity proves that Context Engineering solves the complexity bottleneck. To learn more about this paradigm shift, read our blog post: **[388 Tickets in 6 Weeks: Context Engineering Done Right](.\u002Flearn\u002Fblog\u002Fcontext-engineering-done-right.md)**.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🔗 The Neural Link: Your App is a Living Graph\n\n**Most frameworks offer a \"Read-Only\" view of your code to AI. Neo.mjs offers \"Read\u002FWrite\" access to the Runtime.**\n\nBecause Neo.mjs components are persistent objects (Lego Technic) rather than transient DOM nodes (Melted Plastic), the **Neural Link** allows AI agents to connect directly to the engine's memory.\n\n* **Introspection:** Agents can query the Scene Graph (`get_component_tree`) to understand the exact state of the UI.\n* **Mutation:** Agents can hot-patch class methods, modify state, or re-parent components in real-time without a reload.\n* **Verification:** Agents can simulate user events (clicks, drags) to verify their own fixes.\n\n**[📘 Read the Neural Link Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FNeuralLink.md)**\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🚀 Jump In: Your First Neo.mjs App in Minutes\n\nRun this command:\n\n```bash\nnpx neo-app@latest\n```\n\nThis one-liner sets up everything you need to start building with Neo.mjs, including:\n\n* A new app workspace.\n* A pre-configured app shell.\n* A local development server.\n* Launching your app in a new browser window — all in one go.\n\n:book: More details? Check out our [Getting Started Guide](.\u002F.github\u002FGETTING_STARTED.md)\n\n:student: Make sure to dive into the [Learning Section](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Flearn\u002Fgettingstarted.Setup)\n\nNext steps:\n\n* :star: **Experience stunning Demos & Examples here**: [Neo.mjs Examples Portal](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fexamples)\n* Many more are included inside the repos [apps](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Ftree\u002Fdev\u002Fapps)\n & [examples](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Ftree\u002Fdev\u002Fexamples) folders.\n* :blue_book: All Blog Posts are listed here: [Neo.mjs Blog](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fblog)\n* :robot: Get started with the **[AI Knowledge Base Quick Start Guide](.\u002F.github\u002FAI_QUICK_START.md)**.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 📦 The Object Model: The Scene Graph\n\n**Frameworks compile away. Engines stay alive.**\n\nIn traditional frameworks, the source code is a blueprint that gets destroyed to create the DOM. In Neo.mjs, the source code instantiates a **Scene Graph**—a hierarchy of persistent objects that lives in the App Worker.\n\n* **Lego Technic vs. Duplo:** Most framework components are like \"melted plastic\"—once rendered, they lose their identity. Neo.mjs components are like **Lego Technic**: precision-engineered parts that retain their state, methods, and relationships at runtime.\n* **The JSON Protocol:** Because every component adheres to a strict **serialization protocol** (toJSON), the entire application behaves as a mutable graph.\n* **Runtime Permutation:** This allows AI agents (or you) to inspect, dismantle, and reconfigure the application on the fly—changing layouts, moving dashboards between windows, or hot-swapping themes without a reload.\n\nIt's not just a view library; it's a **construction kit** for adaptive, living applications.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 💡 Why Choose Neo.mjs?\n\n**You're building F1 apps with Toyota parts.**\n\nTraditional frameworks are reliable general-purpose tools (Toyota), sacrificing raw performance for mass adoption. Neo.mjs is precision-engineered for extreme performance (F1), designed for applications where \"good enough\" isn't acceptable.\n\n1. **Eliminate UI Freezes with True Multithreading**:\n > *\"The browser's main thread should be treated like a neurosurgeon: only perform precise, scheduled operations with zero distractions.\"*\u003C\u002Fbr>\u003C\u002Fbr>\n — Neo.mjs Core Philosophy\n\n Neo.mjs's OMT architecture inherently prevents UI freezes. With our optimized rendering pipeline, your UI will remain consistently responsive, even during intense data processing. It achieves an astonishing rate of **over 40,000 delta updates per second** in optimized environments, potential, limited only by user interaction, not the platform.\n\n2. **Unprecedented Velocity with an AI-Native Workflow**:\n The integrated MCP servers provide a \"context-rich\" environment where AI agents can work alongside human developers. This enables autonomous code reviews, deep codebase analysis, and a shared understanding of project history, dramatically accelerating development and solving the \"bus factor\" problem for complex projects.\n\n3. **Build Desktop-Class, Multi-Window Applications**:\n Neo.mjs is the premier solution for building complex, multi-window web applications like **trading platforms, browser-based IDEs, Outlook-style email clients, and multi-screen LLM interfaces**. Its shared worker architecture allows a single application instance to run across multiple browser windows, with real-time state synchronization and the ability to move components between windows seamlessly.\n\n4. **Unmatched Developer Experience: Transpilation-Free ESM**:\n Say goodbye to complex build steps. Neo.mjs apps run **natively as ES Modules directly in the browser**. This means **zero builds or transpilation** in dev mode, offering instant reloads and an unparalleled debugging experience where what you write is what you debug.\n\n5. **Inherent Security by Design**:\n By prioritizing direct DOM API manipulation over string-based methods (like `innerHTML`), Neo.mjs fundamentally reduces the attack surface for vulnerabilities like Cross-Site Scripting (XSS), building a more robust and secure application from the ground up.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 📊 Real-World Win: Crushing UI Lag in Action\n\nImagine a developer building a stock trading app with live feeds updating every millisecond. Traditional frameworks often choke,\nfreezing the UI under the data flood. With Neo.mjs, the heavy lifting happens in worker threads, keeping the main thread free.\nTraders get real-time updates with zero lag, and the app feels like a native desktop tool. Now, imagine extending this with\n**multiple synchronized browser windows**, each displaying different real-time views, all remaining butter-smooth.\nThat’s Neo.mjs in action — solving problems others can’t touch.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🌟 Engine Subsystems (and How They Supercharge Your App)\n\n* **The Threading Subsystem**: A dedicated orchestrator that isolates application logic (App Worker) from rendering logic (Main Thread) and data processing (Data Worker). This ensures the main thread is always free to respond to user input, eliminating UI jank at an architectural level.\n\n* **The Rendering Pipeline**: Just as a game engine sends draw calls to the GPU, the Neo.mjs App Worker sends compressed JSON deltas to the Main Thread. This **Asymmetric VDOM** approach is faster, more secure, and AI-friendly than main-thread diffing.\n\n* **The Scene Graph (Object Permanence)**: Functioning as a persistent Application Engine, Neo.mjs components are **live entities** in the App Worker, functioning like nodes in a Scene Graph. They retain their state and identity even when detached from the DOM. This enables **Runtime Permutation**: the ability to drag active dashboards between windows or re-parent complex tools at runtime without losing context.\n\n* **The Component System**: Neo.mjs offers two powerful component models. **Functional Components**, introduced more recently, provide an easier onboarding experience and a modern, hook-based development style (`defineComponent`, `useConfig`, `useEvent`), similar to other popular frameworks. They are ideal for simpler, more declarative UIs. For advanced use cases requiring granular control over VDOM changes and deeper integration with the engine's lifecycle, **Class-Based Components** offer superior power and flexibility, albeit with slightly more code overhead. Both models seamlessly interoperate, allowing you to choose the right tool for each part of your application while benefiting from the unparalleled performance of our multi-threaded architecture. Best of all, our functional components are free from the \"memoization tax\" (`useMemo`, `useCallback`) that plagues traditional UI libraries.\n\n* **The State Subsystem**: Leveraging `Neo.state.Provider`, Neo.mjs offers natively integrated, hierarchical state management.\n Components declare their data needs via a concise `bind` config. These `bind` functions act as powerful inline formulas, allowing\n Components to automatically react to changes and combine data from multiple state providers within the component hierarchy.\n This ensures dynamic, efficient updates — from simple property changes to complex computed values — all handled off the main thread.\n ```javascript\n \u002F\u002F Example: A component binding its text to state\n static config = {\n bind: {\n \u002F\u002F 'data' here represents the combined state from all parent providers\n myComputedText: data => `User: ${data.userName || 'Guest'} | Status: ${data.userStatus || 'Offline'}`\n }\n }\n ```\n\n* **The Logic Subsystem**: View controllers ensure a clear separation of concerns, isolating business logic\n from UI components for easier maintenance, testing, and team collaboration.\n\n* **Multi-Window & Single-Page Applications (SPAs)***: Beyond traditional SPAs, Neo.mjs excels at complex multi-window applications.\n Its unique architecture, powered by seamless cross-worker communication and extensible Main Thread addons, enables truly native-like, persistent experiences across browser windows.\n\n* **The Module System**: Neo.mjs apps run with **zero runtime dependencies**, just a few dev dependencies for tooling.\n This means smaller bundles, fewer conflicts, and a simpler dependency graph.\n\n* **Unparalleled Debugging Experience**: Benefit from Neo.mjs's built-in debugging capabilities. Easily inspect the full component\n tree across workers, live-modify component configurations directly in the browser console, and observe real-time UI updates,\n all without complex tooling setup.\n\n* **Asymmetric VDOM & JSON Blueprints**: Instead of a complex, class-based VNode tree, your application logic deals with simple, serializable JSON objects. These blueprints are sent to a dedicated VDOM worker for high-performance diffing, ensuring your main thread is never blocked by rendering calculations. This architecture is not only faster but also inherently more secure and easier for AI tools to generate and manipulate.\n\n* **Async-Aware Component Lifecycle**: With the `initAsync()` lifecycle method, components can handle asynchronous setup (like fetching data or lazy-loading modules) *before* they are considered \"ready.\" This eliminates entire classes of race conditions and UI flicker, allowing you to build complex, data-dependent components with confidence.\n\n\u003Cp align=\"center\">\n \u003Cimg src=\".\u002Fresources\u002Fimages\u002Fworkers-focus.svg\" alt=\"Neo.mjs Worker Architecture Diagram - Shows Main Thread, App Worker, VDom Worker, Canvas Worker, Data Worker, Service Worker, Backend connections.\">\n\u003C\u002Fp>\n\n*Diagram: A high-level overview of Neo.mjs's multi-threaded architecture (Main Thread, App Worker, VDom Worker, Canvas Worker, Data Worker, Service Worker, Backend). Optional workers fade in on hover on neomjs.com.*\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🔍 Engine Architecture: The Runtime & The Toolchain\n\nJust as a Game Engine consists of a **Runtime** (what players play) and an **Editor** (what developers use), Neo.mjs is split into two complementary layers.\n\n### 1. The Runtime (Neo.mjs Core)\n*Runs in the Browser. Production-Ready. Zero-Bloat.*\n\nThis is the high-performance engine that powers your application. It operates on a **multi-threaded architecture**, isolating the main thread to ensure 60fps fluidity even under heavy load.\n* **App Worker:** Runs your entire application logic, state, and virtual DOM diffing.\n* **Multi-Window Orchestration:** A single engine instance can power multiple browser windows via SharedWorkers. Components can be dragged, dropped, and moved between windows seamlessly—essential for complex \"Control Room\" interfaces.\n* **Main Thread:** Treated as a \"dumb\" renderer, only applying efficient DOM patches.\n* **Object Permanence:** Components are persistent entities that can be moved, detached, and re-attached without losing state.\n\n### 2. The Toolchain (Agent OS)\n*Runs in Node.js. Dev-Time Only. AI-Native.*\n\nThis is the \"Editor\" for the AI era. It connects your development environment to the running engine, allowing AI agents to act as first-class collaborators.\n* **The Neural Link:** A bi-directional bridge allowing agents to \"see\" and \"mutate\" the live runtime graph.\n* **MCP Servers:** Provide agents with deep context (Knowledge Base) and memory (Memory Core).\n* **Context Engineering:** A structured workflow where agents help you build the engine by understanding its architecture.\n\n**The Result:** You don't just write code; you cultivate a living system with an AI partner that understands exactly how the engine works.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## A Platform at Scale: More Than Just a Library\n\nTo appreciate the scope of Neo.mjs, it's important to understand its scale. This is not a micro-library; it's a comprehensive, enterprise-ready platform representing over a decade of architectural investment. **Neo.mjs is an innovation factory.**\n\nThe stats below, from **January 2026**, provide a snapshot of the ecosystem. For a deeper dive, you can explore the full **[Codebase Overview](.\u002Flearn\u002Fguides\u002Ffundamentals\u002FCodebaseOverview.md)**.\n\n- **~45,000 lines** of core platform source code\n- **~36,000 lines** across hundreds of working examples and flagship applications\n- **~12,000 lines** of production-grade theming\n- **~14,000 lines** of dedicated AI-native infrastructure\n- **~53,000 lines** of detailed JSDoc documentation\n\n**Total: Over 170,000 lines of curated code and documentation.**\n\nThis is not a small library—it's a complete ecosystem with more source code than many established frameworks, designed for the most demanding use cases.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 📚 Foundational Architecture: The Core Principles\n\nThe v10 release marked a significant evolution of the Neo.mjs core, introducing a new functional component model and a revolutionary two-tier reactivity system. These principles form the bedrock of the framework today. We've published a five-part blog series that dives deep into this architecture:\n\n1. **[A Frontend Love Story: Why the Strategies of Today Won't Build the Apps of Tomorrow](.\u002Flearn\u002Fblog\u002Fv10-post1-love-story.md)**\n * *An introduction to the core problems in modern frontend development and the architectural vision of Neo.mjs.*\n2. **[Deep Dive: Named vs. Anonymous State - A New Era of Component Reactivity](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-reactivity.md)**\n * *Explore the powerful two-tier reactivity system that makes the \"memoization tax\" a thing of the past.*\n3. **[Beyond Hooks: A New Breed of Functional Components for a Multi-Threaded World](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-functional-components.md)**\n * *Discover how functional components in a multi-threaded world eliminate the trade-offs of traditional hooks.*\n4. **[Deep Dive: The VDOM Revolution - JSON Blueprints & Asymmetric Rendering](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-vdom-revolution.md)**\n * *Learn how our off-thread VDOM engine uses simple JSON blueprints for maximum performance and security.*\n5. **[Deep Dive: The State Provider Revolution](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-state-provider.md)**\n * *A look into the powerful, hierarchical state management system that scales effortlessly.*\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## ⚙️ Declarative Class Configuration: Build Faster, Maintain Easier\n\nNeo.mjs’s class config system allows you to define and manage classes in a declarative and reusable way. This simplifies\nclass creation, reduces boilerplate code, and improves maintainability.\n\n```javascript\nimport Component from '..\u002F..\u002Fsrc\u002Fcomponent\u002FBase.mjs';\n\n\u002F**\n * Lives within the App Worker\n * @class MyComponent\n * @extends Neo.component.Base\n *\u002F\nclass MyComponent extends Component {\n static config = {\n className : 'MyComponent',\n myConfig_ : 'defaultValue', \u002F\u002F Reactive property\n domListeners: { \u002F\u002F Direct DOM event binding\n click: 'onClick'\n }\n }\n\n \u002F\u002F Triggered automatically by the config setter when myConfig changes\n afterSetMyConfig(value, oldValue) {\n console.log('myConfig changed:', value, oldValue);\n }\n\n \u002F\u002F Executed in the App Worker. The Main Thread (UI) never sees this logic.\n onClick(data) {\n console.log('Clicked!', data);\n }\n}\n\nexport default Neo.setupClass(MyComponent);\n\n\u002F\u002F -------------------------------------------------------\n\u002F\u002F The Engine allows Runtime Mutation:\n\u002F\u002F An AI agent (or you) can inspect and modify this instance LIVE without a reload.\n\u002F\u002F -------------------------------------------------------\n\n\u002F\u002F Agent Command (via Neural Link):\nNeo.get('my-component-id').set({\n myConfig: 'newValue',\n style : { color: 'red' } \u002F\u002F Instant update via OMT Rendering Pipeline. No build step. No reload.\n});\n```\n\nFor each config property ending with an underscore (_), Neo.mjs automatically generates a getter and a setter on the class prototype. These setters ensure that changes trigger corresponding lifecycle hooks, providing a powerful, built-in reactive system:\n\n* `beforeGetMyConfig(value)`\u003C\u002Fbr>\n (Optional) Called before the config value is returned via its getter, allowing for last-minute transformations.\n* `beforeSetMyConfig(value, oldValue)`\u003C\u002Fbr>\n (Optional) Called before the config value is set, allowing you to intercept, validate, or modify the new value. Returning undefined will cancel the update.\n* `afterSetMyConfig(value, oldValue)`\u003C\u002Fbr>\n (Optional) Called after the config value has been successfully set and a change has been detected, allowing for side effects or reactions to the new value.\n\nFor more details, check out the [Class Config System documentation](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002Findex.html#\u002Flearn\u002Fgettingstarted.Config).\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🤝 Community & Support\n\nHave a question or want to connect with the community? We have two channels to help you out.\n\n* **[💬 Discord (Recommended for Questions & History)](https:\u002F\u002Fdiscord.gg\u002F6p8paPq):** Our primary community hub. All conversations are permanently archived and searchable, making it the best place to ask questions and find past answers.\n* **[⚡️ Slack (For Real-Time Chat)](https:\u002F\u002Fjoin.slack.com\u002Ft\u002Fneomjs\u002Fshared_invite\u002Fzt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA):** Perfect for quick, real-time conversations. Please note that the free version's history is temporary (messages are deleted after 90 days).\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🧭 Vision & Roadmap\n\nTo understand the long-term goals and future direction of the project, please see our strategic documents:\n\n* **[✨ The Vision](.\u002F.github\u002FVISION.md):** Learn about the core philosophy and the \"why\" behind our architecture.\n* **[🗺️ The Roadmap](.\u002FROADMAP.md):** See what we're working on now and what's planned for the future.\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## :handshake: How to Contribute\n\n:hammer_and_wrench: Want to contribute? Check out our [Contributing Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002FCONTRIBUTING.md).\n\n\u003C\u002Fbr>\u003C\u002Fbr>\nCopyright (c) 2015 - today, [Tobias Uhlig](https:\u002F\u002Fwww.linkedin.com\u002Fin\u002Ftobiasuhlig\u002F)\n","\u003Cp align=\"center\">\n \u003Cimg height=\"100\"src=\"https:\u002F\u002Fraw.githubusercontent.com\u002Fneomjs\u002Fpages\u002Fmain\u002Fresources_pub\u002Fimages\u002Flogo\u002Fneo_logo_text_primary.svg\" alt=\"Neo.mjs 徽标\">\n\u003C\u002Fp>\n\u003C\u002Fbr>\n\u003Cp align=\"center\">\n \u003Ca href=\"https:\u002F\u002Fnpmcharts.com\u002Fcompare\u002Fneo.mjs?minimal=true\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fdm\u002Fneo.mjs.svg?label=下载量\" alt=\"下载量\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fneo.mjs\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fv\u002Fneo.mjs.svg?logo=npm\" alt=\"版本\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fwww.npmjs.com\u002Fpackage\u002Fneo.mjs\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fnpm\u002Fl\u002Fneo.mjs.svg?label=许可证\" alt=\"许可证\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fjoin.slack.com\u002Ft\u002Fneomjs\u002Fshared_invite\u002Fzt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FSlack-Neo.mjs-brightgreen.svg?logo=slack\" alt=\"加入 Slack 频道\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fdiscord.gg\u002F6p8paPq\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fdiscord\u002F656620537514164249?label=Discord&logo=discord&logoColor=white\" alt=\"Discord 聊天\">\u003C\u002Fa>\n \u003Ca href=\".\u002FCONTRIBUTING.md\">\u003Cimg src=\"https:\u002F\u002Fimg.shields.io\u002Fbadge\u002FPRs-welcome-green.svg?logo=GitHub&logoColor=white\" alt=\"欢迎提交 PR\">\u003C\u002Fa>\n\u003C\u002Fp>\n\n# AI 时代的应用引擎\n🚀 **真正的多线程遇上上下文工程 —— 与 AI 协作者一起构建桌面级 UI。**\n\n> **⚡ 心智模型：**\n> **Neo.mjs 是一个多线程应用运行时，其中 UI 组件是持久化对象——而非短暂的渲染结果。**\n> 这种架构转变实现了桌面级性能、多窗口编排以及传统框架无法实现的 AI 驱动运行时变更。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n💻 ***Neo.mjs 不是一个框架；它是面向 Web 的应用引擎。正如 Unreal Engine 为游戏提供完整的运行时和工具链，Neo.mjs 为企业应用提供多线程运行时和 AI 原生工具链。***\n\n想象一下从不卡顿的 Web 应用，无论逻辑多么复杂、处理多少实时更新，或跨越多少个浏览器窗口。Neo.mjs 从头开始设计，旨在提供**桌面般的流畅性和可扩展性**。**虽然它在单页应用（SPA）中表现出色，但 Neo.mjs 无疑是基于浏览器的多窗口应用的最佳选择**，其运行方式与传统框架有着根本不同。\n\n通过利用**开创性的主线程外（OMT）架构**，Neo.mjs 确保您的 UI 保持如黄油般顺滑。主线程仅保留一个用途：**完美无瑕的用户交互和无缝的 DOM 更新。**\n\n\u003Cp align=\"center\">\n \u003Ca href=\"https:\u002F\u002Fyoutu.be\u002FpYfM28Pz6_0\">\u003Cimg height=\"316px\" width=\"400px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_05ee37717533.png\" alt=\"Neo.mjs 性能演示 1（YouTube 视频）\">\u003C\u002Fa>\n \u003Ca href=\"https:\u002F\u002Fyoutu.be\u002FaEA5333WiWY\">\u003Cimg height=\"316px\" width=\"400px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_3e6f48ce24c5.png\" alt=\"Neo.mjs 性能演示 2（YouTube 视频）\">\u003C\u002Fa>\n\u003C\u002Fp>\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🎯 Neo.mjs 适合您吗？\n\n**Neo.mjs 是一个应用引擎，而非网站构建器。**\n*这是一个成熟的企业级平台，拥有超过 13 万行生产就绪代码。*\n\n✅ **适用于：**\n* **金融与交易平台：** 每秒处理 1 万+数据更新而不冻结 UI。\n* **多窗口工作区：** 跨越多屏幕的 IDE、控制室和仪表板。\n* **AI 原生界面：** UI 结构必须在运行时由 AI Agent 变更的应用。\n* **企业级 SPA：** 需要桌面应用稳定性的复杂逻辑。\n\n❌ **不适用于：**\n* 静态内容网站或简单博客（请使用 Astro\u002FNext.js）。\n* 寻找“不同语法的 React”的团队。\n* 不愿接受 Actor 模型（Workers）的开发者。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🚀 AI 原生开发平台\n\nNeo.mjs v11 引入了一种革命性的软件开发方法：**上下文工程**。我们已超越简单的“AI 辅助”编码，创建了一个真正的 **AI 原生**平台，其中 AI Agent 是开发过程中深度集成的合作伙伴。这得益于一套专用的**模型上下文协议（MCP）服务器**，为 Agent 提供理解、构建和推理代码所需的上下文。\n\n这不仅仅是生成代码；而是要创建一个自感知的开发环境，以加速开发速度、提高质量，并实现全新的人机协作水平。\n\n\u003Cp align=\"center\">\n \u003Cimg width=\"800px\" src=\"https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_readme_baceab19886b.png\" alt=\"Context Engineering Done Right\" class=\"blog-image\">\n\u003C\u002Fp>\n\n1. **🧠 知识库服务器**：为 Agent 提供对项目的深度语义理解。由 ChromaDB 和 Gemini 嵌入提供支持，它允许 Agent 在整个代码库、文档和历史工单中执行语义搜索。Agent 可以提问“VDOM 比对是如何工作的？”，并获得与*当前检出版本*相关的精确源文件和架构指南。\n * **[📘 阅读指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FKnowledgeBase.md)**\n\n2. **💾 内存核心服务器**：为 Agent 提供持久化、长期记忆。每一次交互——提示、思维过程和响应都被存储，使 Agent 能够从经验中学习、回忆过去的决策，并在多个会话之间保持上下文。这将 Agent 从一个无状态工具转变为与项目共同成长的真正协作者。\n * **[📘 阅读指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FMemoryCore.md)**\n\n3. **🤖 GitHub 工作流服务器**：通过让 Agent 直接参与项目生命周期来闭环。它提供用于自主 PR 审查、问题管理以及将 GitHub 问题双向同步到本地可查询的 Markdown 文件集的工具。这消除了代码审查和项目管理中的人为瓶颈。\n * **[📘 阅读指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FGitHubWorkflow.md)**\n\n4. **⚡️ Agent 运行时**：让您的 Agent 作为自主开发者行动。Agent 无需被动地请求信息，而是可以使用 **Neo.mjs AI SDK** 编写并执行复杂脚本。这实现了自愈代码、自动重构和数据迁移等高级工作流——在本地以机器速度运行。\n * **[📘 阅读指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FCodeExecution.md)**\n\n### 为什么引擎架构对 AI 至关重要\n在传统编译型框架（React、Svelte）中，AI agents（AI 代理）是\"盲目\"的，因为它们编写的代码（JSX\u002F模板）在构建步骤中被销毁——运行时的真实状态（DOM 节点）与源代码完全不同。\n\n**在 Neo.mjs 中，地图即领土。** 因为组件是 App Worker 中的持久化对象（而非临时的 DOM 节点），AI 可以随时查询它们的状态、方法和继承链。这就像在 Unreal Engine 中检查一个正在运行的游戏角色，而不是解析屏幕上的像素。AI 看到的正是引擎所看到的，使其能够完美准确地推理状态、继承和拓扑结构。此外，**Neural Link** 允许代理查询运行时的 **Ground Truth（真实状态）**，从而验证现实并解决静态分析无法处理的复杂运行时依赖问题。\n\n这套强大的工具链是与 AI 代理共同创建的，使我们能够在短短 6 周内交付 **388 项架构增强**。这种数量级的速度提升证明了 Context Engineering（上下文工程）解决了复杂性瓶颈。要了解更多关于这一范式转变的信息，请阅读我们的博客文章：**[6 周完成 388 个任务：Context Engineering Done Right（正确的上下文工程实践）](.\u002Flearn\u002Fblog\u002Fcontext-engineering-done-right.md)**。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🔗 Neural Link：你的应用是一个活的图\n\n**大多数框架为 AI 提供代码的\"只读\"视图。Neo.mjs 提供对运行时的\"读写\"访问。**\n\n因为 Neo.mjs 组件是持久化对象（乐高机械组）而非临时的 DOM 节点（融化塑料），**Neural Link** 允许 AI 代理直接连接到引擎的内存。\n\n* **Introspection（内省）：** 代理可以查询 Scene Graph（场景图）（`get_component_tree`）以了解 UI 的精确状态。\n* **Mutation（变更）：** 代理可以 hot-patch（热补丁）类方法、修改状态或实时 re-parent（重新父级化）组件，无需重新加载。\n* **Verification（验证）：** 代理可以模拟用户事件（点击、拖拽）来验证它们自己的修复。\n\n**[📘 阅读 Neural Link 指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fmcp\u002FNeuralLink.md)**\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🚀 快速开始：几分钟内创建你的第一个 Neo.mjs 应用\n\n运行以下命令：\n\n```bash\nnpx neo-app@latest\n```\n\n这一行命令会设置你开始使用 Neo.mjs 构建所需的一切，包括：\n\n* 一个新的应用工作区。\n* 一个预配置的应用外壳。\n* 一个本地开发服务器。\n* 在新浏览器窗口中启动你的应用——一步到位。\n\n:book: 需要更多细节？请查看我们的[入门指南](.\u002F.github\u002FGETTING_STARTED.md)\n\n:student: 务必深入探索[学习专区](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Flearn\u002Fgettingstarted.Setup)\n\n下一步：\n\n* :star: **在此体验精彩的演示和示例**：[Neo.mjs 示例门户](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fexamples)\n* 更多示例包含在仓库的 [apps](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Ftree\u002Fdev\u002Fapps)\n & [examples](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Ftree\u002Fdev\u002Fexamples) 文件夹中。\n* :blue_book: 所有博客文章列在这里：[Neo.mjs 博客](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fblog)\n* :robot: 开始使用 **[AI 知识库快速入门指南](.\u002F.github\u002FAI_QUICK_START.md)**。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 📦 对象模型：场景图\n\n**框架会编译消失。引擎保持存活。**\n\n在传统框架中，源代码是创建 DOM 时会被销毁的蓝图。在 Neo.mjs 中，源代码实例化一个 **Scene Graph（场景图）**——一个存在于 App Worker 中的持久化对象层级结构。\n\n* **Lego Technic（乐高机械组）vs. Duplo（得宝）：** 大多数框架组件就像\"融化塑料\"——一旦渲染，就失去了身份。Neo.mjs 组件就像 **Lego Technic（乐高机械组）**：精密设计的部件，在运行时保留其状态、方法和关系。\n* **JSON 协议：** 因为每个组件都遵循严格的 **serialization protocol（序列化协议）**（toJSON），整个应用程序表现为一个可变的图。\n* **Runtime Permutation（运行时置换）：** 这允许 AI 代理（或你）即时检查、拆解和重新配置应用——更改布局、在窗口间移动仪表板或热切换主题，无需重新加载。\n\n它不仅仅是一个视图库；它是构建自适应、活应用的 **construction kit（构建工具包）**。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 💡 为什么选择 Neo.mjs？\n\n**你在用丰田零件制造 F1 赛车。**\n\n传统框架是可靠的通用工具（丰田），为大规模采用牺牲了原始性能。Neo.mjs 为极致性能而精密设计（F1），专为\"足够好\"不可接受的应用而设计。\n\n1. **通过真正的多线程消除 UI 冻结**：\n > *\"浏览器的主线程应该像神经外科医生一样对待：只执行精确、有计划的操作，零干扰。\"*\u003C\u002Fbr>\u003C\u002Fbr>\n — Neo.mjs 核心哲学\n\n Neo.mjs 的 OMT 架构从根本上防止 UI 冻结。通过优化的渲染管线，即使在密集数据处理期间，您的 UI 也能保持持续响应。在优化环境中，它实现了惊人的**每秒超过 40,000 次 delta updates（增量更新）**速率，潜力仅受用户交互限制，而非平台限制。\n\n2. **AI 原生工作流带来前所未有的速度**：\n 集成的 MCP 服务器提供了一个\"上下文丰富\"的环境，AI 代理可以与人类开发者并肩工作。这使得自主代码审查、深度代码库分析以及对项目历史的共同理解成为可能，极大地加速了开发，并解决了复杂项目的 **bus factor（巴士因子）** 问题。\n\n3. **构建桌面级、多窗口应用**：\n Neo.mjs 是构建复杂多窗口 Web 应用的首选解决方案，如**交易平台、基于浏览器的 IDE、Outlook 风格的邮件客户端和多屏 LLM 界面**。其共享 worker 架构允许单个应用实例在多个浏览器窗口中运行，具有实时状态同步和无缝跨窗口移动组件的能力。\n\n4. **无与伦比的开发者体验：无需转译的 ESM**：\n 告别复杂的构建步骤。Neo.mjs 应用**以 ES 模块（ES Modules）形式直接在浏览器中原生运行**。这意味着开发模式下**零构建或转译**，提供即时重载和前所未有的调试体验，所见即所调。\n\n5. **设计固有的安全性**：\n 通过优先使用直接 DOM API 操作而非基于字符串的方法（如 `innerHTML`），Neo.mjs 从根本上减少了跨站脚本攻击（Cross-Site Scripting, **XSS**）等漏洞的攻击面，从一开始就构建更健壮、更安全的应用。\n\n## 📊 实战胜利：彻底消除 UI 延迟（UI Lag）\n\n想象一下，一位开发者正在构建一个股票交易应用，其实时数据流每毫秒都在更新。传统框架往往会不堪重负，在数据洪流下冻结 UI。而使用 Neo.mjs，繁重的处理工作在 worker 线程（工作线程）中完成，让主线程（main thread）保持空闲。交易者可以获得零延迟的实时更新，应用体验如同原生桌面工具。现在，想象一下将这一能力扩展到**多个同步的浏览器窗口**，每个窗口显示不同的实时视图，全部保持如黄油般顺滑。这就是 Neo.mjs 的实战能力——解决其他框架无法触及的问题。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🌟 引擎子系统（Engine Subsystems）及其如何为您的应用注入超强动力\n\n* **线程子系统（Threading Subsystem）**：一个专用的协调器，将应用逻辑（App Worker）与渲染逻辑（Main Thread）以及数据处理（Data Worker）隔离开来。这确保了主线程始终可以响应用户输入，从而在架构层面消除 UI 卡顿（UI jank）。\n\n* **渲染管线（Rendering Pipeline）**：正如游戏引擎向 GPU（图形处理器）发送绘制调用（draw calls），Neo.mjs 的 App Worker 向主线程发送压缩的 JSON 增量。这种**非对称 VDOM（Asymmetric VDOM）**方法比主线程 diff 操作更快、更安全，也更适合 AI。\n\n* **场景图（对象持久性，Object Permanence）**：作为持久化应用引擎，Neo.mjs 组件在 App Worker 中是**活跃实体（live entities）**，如同场景图（Scene Graph）中的节点。即使从 DOM 中分离，它们也能保留自身状态和身份。这实现了**运行时变换（Runtime Permutation）**：能够在运行时拖动活跃仪表板跨窗口，或重新挂载复杂工具而不丢失上下文。\n\n* **组件系统（Component System）**：Neo.mjs 提供两种强大的组件模型。**函数式组件（Functional Components）**是近期引入的，提供了更简单的上手体验和现代的、基于 hook 的开发风格（`defineComponent`、`useConfig`、`useEvent`），与其他流行框架类似，非常适合更简单、更具声明性的 UI。对于需要精细控制 VDOM 变更以及与引擎生命周期深度集成的高级用例，**类组件（Class-Based Components）**提供了更强大的功能和灵活性，尽管代码开销稍大。两种模型可以无缝互操作，让您为应用的每个部分选择合适的工具，同时享受我们多线程架构带来的无与伦比的性能。最重要的是，我们的函数式组件免受了传统 UI 库困扰的\"记忆化开销（memoization tax）\"（`useMemo`、`useCallback`）之苦。\n\n* **状态子系统（State Subsystem）**：借助 `Neo.state.Provider`，Neo.mjs 提供了原生集成的分层状态管理。组件通过简洁的 `bind` 配置声明其数据需求。这些 `bind` 函数充当强大的内联公式，允许组件自动响应变更，并在组件层级内组合来自多个状态提供者的数据。这确保了动态、高效的更新——从简单的属性变更到复杂的计算值——全部在主线程之外处理。\n ```javascript\n \u002F\u002F Example: A component binding its text to state\n static config = {\n bind: {\n \u002F\u002F 'data' here represents the combined state from all parent providers\n myComputedText: data => `User: ${data.userName || 'Guest'} | Status: ${data.userStatus || 'Offline'}`\n }\n }\n ```\n\n* **逻辑子系统（Logic Subsystem）**：视图控制器（View controllers）确保清晰的关注点分离，将业务逻辑与 UI 组件隔离，便于维护、测试和团队协作。\n\n* **多窗口与单页应用（SPAs）**：除了传统的 SPA，Neo.mjs 在复杂的多窗口应用方面表现出色。其独特的架构通过无缝的跨 worker 通信和可扩展的主线程插件（Main Thread addons），实现了真正类似原生、跨浏览器窗口的持久化体验。\n\n* **模块系统（Module System）**：Neo.mjs 应用以**零运行时依赖**运行，仅包含少量用于工具链的开发依赖。这意味着更小的包体积、更少的冲突和更简单的依赖关系图。\n\n* **无与伦比的调试体验**：受益于 Neo.mjs 内置的调试能力。可以轻松检查跨 worker 的完整组件树，直接在浏览器控制台中实时修改组件配置，并观察实时 UI 更新，所有这些都无需复杂的工具链设置。\n\n* **非对称 VDOM 与 JSON 蓝图**：应用逻辑处理的是简单的、可序列化的 JSON 对象，而非复杂的、基于类的 VNode 树。这些蓝图被发送到专用的 VDOM worker 进行高性能 diff 操作，确保主线程永远不会被渲染计算阻塞。这种架构不仅更快，而且本质上更安全，也更易于 AI 工具生成和操作。\n\n* **异步感知组件生命周期**：通过 `initAsync()` 生命周期方法，组件可以在被视为\"就绪\"**之前**处理异步初始化（如获取数据或懒加载模块）。这消除了整类竞态条件（race conditions）和 UI 闪烁（UI flicker），让您能够自信地构建复杂的数据依赖组件。\n\n\u003Cp align=\"center\">\n \u003Cimg src=\".\u002Fresources\u002Fimages\u002Fworkers-focus.svg\" alt=\"Neo.mjs Worker Architecture Diagram - Shows Main Thread, App Worker, VDom Worker, Canvas Worker, Data Worker, Service Worker, Backend connections.\">\n\u003C\u002Fp>\n\n*图示：Neo.mjs 多线程架构的高层次概览（主线程 Main Thread、App Worker、VDom Worker、Canvas Worker、Data Worker、Service Worker、后端）。可选 worker 在 neomjs.com 上悬停时淡入。*\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🔍 引擎架构：运行时（Runtime）与工具链（Toolchain）\n\n正如游戏引擎（Game Engine）由**运行时（Runtime）**（玩家使用的部分）和**编辑器（Editor）**（开发者使用的部分）组成，Neo.mjs 也分为两个互补的层。\n\n### 1. 运行时（Neo.mjs 核心）\n*在浏览器中运行。生产就绪（Production-Ready）。零膨胀（Zero-Bloat）。*\n\n这是驱动您应用的高性能引擎。它基于**多线程架构（multi-threaded architecture）**运行，隔离主线程以确保即使在重负载下也能保持 60fps 的流畅度。\n* **App Worker：** 运行您的整个应用逻辑、状态和虚拟 DOM diff。\n* **多窗口编排（Multi-Window Orchestration）：** 单个引擎实例可以通过 SharedWorkers（共享 worker）驱动多个浏览器窗口。组件可以无缝地在窗口之间拖放和移动——这对于复杂的\"控制室（Control Room）\"界面至关重要。\n* **主线程（Main Thread）：** 被视为\"哑渲染器\"，仅应用高效的 DOM 补丁。\n* **对象持久性（Object Permanence）：** 组件是持久化实体，可以被移动、分离和重新挂载而不会丢失状态。\n\n### 2. 工具链（Agent OS）\n*运行于 Node.js。仅开发时使用。AI 原生。*\n\n这是 AI 时代的\"编辑器\"。它将你的开发环境与运行中的引擎连接起来，让 AI 代理成为一等协作者（first-class collaborators）。\n* **Neural Link（神经链接）：** 一个双向桥梁，允许代理\"查看\"和\"修改\"实时运行时图谱。\n* **MCP Servers（MCP 服务器）：** 为代理提供深度上下文（Knowledge Base\u002F知识库）和记忆（Memory Core\u002F记忆核心）。\n* **Context Engineering（上下文工程）：** 一种结构化工作流，代理通过理解引擎架构来帮助你构建引擎。\n\n**结果：** 你不仅仅是编写代码；你是在与一位完全理解引擎工作原理的 AI 伙伴共同培育一个活的系统。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 规模化平台：不仅仅是库\n\n要理解 Neo.mjs 的广度，重要的是了解它的规模。这不是一个微型库；而是一个全面的、企业级平台（enterprise-ready platform），代表了超过十年的架构投入。**Neo.mjs 是一个创新工厂（innovation factory）。**\n\n以下统计数据来自 **2026 年 1 月**，展示了生态系统的概况。如需深入了解，你可以探索完整的 **[代码库概览](.\u002Flearn\u002Fguides\u002Ffundamentals\u002FCodebaseOverview.md)**。\n\n- **约 45,000 行** 核心平台源代码\n- **约 36,000 行** 数百个实用示例和旗舰应用代码\n- **约 12,000 行** 生产级主题系统（production-grade theming）\n- **约 14,000 行** 专用 AI 原生基础设施（AI-native infrastructure）\n- **约 53,000 行** 详细的 JSDoc 文档\n\n**总计：超过 170,000 行精心策划的代码和文档。**\n\n这不是一个小型库——它是一个完整的生态系统，源代码行数超过许多成熟框架，专为最苛刻的使用场景而设计。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 📚 基础架构：核心原则\n\nv10 版本标志着 Neo.mjs 核心的重大演进，引入了全新的函数式组件模型（functional component model）和革命性的双层响应式系统（two-tier reactivity system）。这些原则构成了框架今天的基石。我们发布了一个五篇博客系列，深入探讨这一架构：\n\n1. **[前端爱情故事：为何今天的策略无法构建明天的应用](.\u002Flearn\u002Fblog\u002Fv10-post1-love-story.md)**\n * *介绍现代前端开发中的核心问题以及 Neo.mjs 的架构愿景。*\n2. **[深度解析：命名状态 vs 匿名状态——组件响应性的新时代](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-reactivity.md)**\n * *探索强大的双层响应式系统，让\"记忆化开销（memoization tax）\"成为过去。*\n3. **[超越 Hooks：面向多线程世界的新型函数式组件](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-functional-components.md)**\n * *了解多线程世界中的函数式组件如何消除传统 hooks 的权衡。*\n4. **[深度解析：VDOM 革命——JSON 蓝图与非对称渲染](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-vdom-revolution.md)**\n * *学习我们的离线程 VDOM 引擎如何使用简单的 JSON 蓝图（JSON Blueprints）实现最大性能和安全性。*\n5. **[深度解析：状态提供者革命](.\u002Flearn\u002Fblog\u002Fv10-deep-dive-state-provider.md)**\n * *深入了解强大、可轻松扩展的分层状态管理（hierarchical state management）系统。*\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## ⚙️ 声明式类配置：更快构建，更易维护\n\nNeo.mjs 的类配置系统（class config system）允许你以声明式且可复用的方式定义和管理类。这简化了类创建，减少了样板代码（boilerplate code），并提高了可维护性。\n\n```javascript\nimport Component from '..\u002F..\u002Fsrc\u002Fcomponent\u002FBase.mjs';\n\n\u002F**\n * Lives within the App Worker\n * @class MyComponent\n * @extends Neo.component.Base\n *\u002F\nclass MyComponent extends Component {\n static config = {\n className : 'MyComponent',\n myConfig_ : 'defaultValue', \u002F\u002F Reactive property\n domListeners: { \u002F\u002F Direct DOM event binding\n click: 'onClick'\n }\n }\n\n \u002F\u002F Triggered automatically by the config setter when myConfig changes\n afterSetMyConfig(value, oldValue) {\n console.log('myConfig changed:', value, oldValue);\n }\n\n \u002F\u002F Executed in the App Worker. The Main Thread (UI) never sees this logic.\n onClick(data) {\n console.log('Clicked!', data);\n }\n}\n\nexport default Neo.setupClass(MyComponent);\n\n\u002F\u002F -------------------------------------------------------\n\u002F\u002F The Engine allows Runtime Mutation:\n\u002F\u002F An AI agent (or you) can inspect and modify this instance LIVE without a reload.\n\u002F\u002F -------------------------------------------------------\n\n\u002F\u002F Agent Command (via Neural Link):\nNeo.get('my-component-id').set({\n myConfig: 'newValue',\n style : { color: 'red' } \u002F\u002F Instant update via OMT Rendering Pipeline. No build step. No reload.\n});\n```\n\n对于每个以下划线（_）结尾的配置属性，Neo.mjs 会自动在类原型上生成 getter 和 setter。这些 setter 确保变更会触发相应的生命周期钩子（lifecycle hooks），提供强大的内置响应式系统：\n\n* `beforeGetMyConfig(value)`\u003C\u002Fbr>\n （可选）在通过 getter 返回配置值之前调用，允许进行最后一刻的转换。\n* `beforeSetMyConfig(value, oldValue)`\u003C\u002Fbr>\n （可选）在设置配置值之前调用，允许你拦截、验证或修改新值。返回 undefined 将取消更新。\n* `afterSetMyConfig(value, oldValue)`\u003C\u002Fbr>\n （可选）在配置值已成功设置并检测到变更后调用，允许执行副作用或响应新值。\n\n更多详情，请查看 [类配置系统文档](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002Findex.html#\u002Flearn\u002Fgettingstarted.Config)。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🤝 社区与支持\n\n有问题或想与社区交流？我们有两个渠道可以帮助你。\n\n* **[💬 Discord（推荐用于提问和历史记录）](https:\u002F\u002Fdiscord.gg\u002F6p8paPq)：** 我们的主要社区中心。所有对话都会永久存档且可搜索，是提问和查找过往答案的最佳场所。\n* **[⚡️ Slack（用于实时聊天）](https:\u002F\u002Fjoin.slack.com\u002Ft\u002Fneomjs\u002Fshared_invite\u002Fzt-6c50ueeu-3E1~M4T9xkNnb~M_prEEOA)：** 适合快速、实时的对话。请注意，免费版的历史记录是临时的（消息会在 90 天后删除）。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n## 🧭 愿景与路线图\n\n要了解项目的长期目标和未来方向，请查看我们的战略文档：\n\n* **[✨ 愿景](.\u002F.github\u002FVISION.md)：** 了解核心哲学以及我们架构背后的\"为什么\"。\n* **[🗺️ 路线图](.\u002FROADMAP.md)：** 查看我们正在开发的内容以及未来的计划。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n\n## :handshake: 如何贡献\n\n:hammer_and_wrench: 想要参与贡献吗？请查看我们的[贡献指南](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002FCONTRIBUTING.md)。\n\n\u003C\u002Fbr>\u003C\u002Fbr>\n版权所有 (c) 2015 - 至今，[Tobias Uhlig](https:\u002F\u002Fwww.linkedin.com\u002Fin\u002Ftobiasuhlig\u002F)","# Neo.mjs 快速上手指南\n\n## 环境准备\n\n### 系统要求\n- **操作系统**：Windows 10\u002F11、macOS 10.15+ 或 Linux\n- **Node.js**：v18.0.0 或更高版本（推荐 v20+）\n- **npm**：v9.0.0 或更高版本（随 Node.js 一起安装）\n- **浏览器**：Chrome 90+、Firefox 88+、Safari 14+ 或 Edge 90+\n\n### 前置依赖\n确保已安装 Node.js 和 npm：\n\n```bash\nnode --version\nnpm --version\n```\n\n如果未安装，请访问 [Node.js 官网](https:\u002F\u002Fnodejs.org\u002F) 下载并安装 LTS 版本。\n\n## 安装步骤\n\n使用以下命令一键创建并启动你的第一个 Neo.mjs 应用：\n\n```bash\nnpx neo-app@latest\n```\n\n该命令将自动完成：\n- 创建新的应用工作区\n- 生成预配置的应用外壳\n- 安装所有依赖包\n- 启动本地开发服务器\n- 在浏览器中打开应用\n\n**注意**：首次运行可能需要几分钟时间下载依赖，请耐心等待。\n\n## 基本使用\n\n### 启动开发服务器\n命令执行成功后，开发服务器会自动启动并打开浏览器窗口。默认访问地址为：\n- **本地地址**：`http:\u002F\u002Flocalhost:8080`\n\n### 项目结构\n创建完成后，你的项目将包含以下核心目录：\n```\nmy-neo-app\u002F\n├── apps\u002F # 应用主代码\n├── resources\u002F # 静态资源\n├── src\u002F # 源码\n└── neo-config.json # 配置文件\n```\n\n### 开发流程\n1. **修改代码**：编辑 `apps\u002F` 目录下的组件文件\n2. **实时预览**：保存后浏览器自动刷新（热更新）\n3. **构建生产版本**：运行 `npm run build` 生成优化后的生产包\n\n### 下一步学习\n- **体验官方示例**：[Neo.mjs 示例门户](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fexamples)\n- **查看完整教程**：[入门指南](.\u002F.github\u002FGETTING_STARTED.md)\n- **AI 开发指南**：[AI 知识库快速入门](.\u002F.github\u002FAI_QUICK_START.md)\n- **在线学习资源**：[Neo.mjs 学习中心](https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Flearn\u002Fgettingstarted.Setup)\n\n---\n\n**提示**：Neo.mjs 采用多线程架构，所有业务逻辑在 Web Worker 中运行，主线程仅负责 DOM 更新，确保 UI 始终保持流畅。","某量化交易团队正在开发一个跨三屏的实时监控平台，左侧屏幕显示市场深度与订单流，中间屏幕运行策略回测图表，右侧屏幕展示风险仪表盘。团队希望集成AI风控助手，能根据市场波动自动调整监控重点。\n\n### 没有 neo 时\n- **界面频繁卡顿**：每秒钟上万笔行情数据涌入时，主线程被计算和渲染双重占用，鼠标拖拽窗口都会出现肉眼可见的延迟，交易员在波动剧烈时无法及时操作。\n- **多窗口状态失控**：弹出详情窗口或扩展新屏幕时，需要手动编写复杂的消息同步逻辑，窗口间数据常出现不一致，调试耗时占开发周期的30%以上。\n- **AI成\"局外人\"**：风控AI只能输出文本建议，无法直接调整界面。当检测到异常波动时，仍需交易员手动切换视图、放大关键图表，响应延迟长达数秒。\n- **扩展陷入死胡同**：随着策略增多，SPA的内存占用持续攀升，浏览器标签页崩溃成为常态，团队不得不限制功能迭代速度。\n\n### 使用 neo 后\n- **交易级流畅体验**：行情数据在后台Worker线程处理，主线程仅负责DOM更新。即使处理15,000笔\u002F秒的峰值数据，界面响应速度仍保持在16ms以内，鼠标操作如丝般顺滑。\n- **场景图自动同步**：neo的持久化场景图天然支持多窗口，新弹出的风险告警窗口自动共享应用状态，无需编写任何同步代码。关闭窗口时状态自动回收，开发效率提升50%。\n- **AI成为\"联合驾驶员\"**：风控AI直接内省场景图，发现异常时实时修改组件属性——自动放大VIX波动率图表、高亮异常订单簿区域、甚至重组布局。响应时间缩短至200毫秒内。\n- **性能天花板消失**：多线程架构将计算负载均匀分布，内存使用稳定可控。团队可以大胆添加新功能，不再担心浏览器成为瓶颈。\n\nneo让量化平台真正实现了\"人机协同\"的实时响应，将AI从建议者升级为能直接操控界面的执行者，同时保持桌面级性能。","https:\u002F\u002Foss.gittoolsai.com\u002Fimages\u002Fneomjs_neo_a60e667d.png","neomjs","neo.mjs","https:\u002F\u002Foss.gittoolsai.com\u002Favatars\u002Fneomjs_fa09d2b3.png","collection of all neo.mjs related repositories",null,"https:\u002F\u002Fneomjs.github.io\u002Fpages\u002F","https:\u002F\u002Fgithub.com\u002Fneomjs",[84,88,92],{"name":85,"color":86,"percentage":87},"JavaScript","#f1e05a",91.1,{"name":89,"color":90,"percentage":91},"SCSS","#c6538c",8.5,{"name":93,"color":94,"percentage":95},"HTML","#e34c26",0.4,3167,202,"2026-04-05T10:59:18","MIT",4,"Linux, macOS, Windows","未说明",{"notes":104,"python":102,"dependencies":105},"需要在支持 Web Workers 的现代浏览器环境中运行。开发环境需要 Node.js 和 npm。框架采用 Off-Main-Thread (OMT) 多线程架构，要求开发者理解 Actor 模型。AI 原生功能需要配置 MCP 服务器（知识库、内存核心、GitHub 工作流、代理运行时）。不适合静态网站或简单博客，专为企业级单页应用和多窗口应用设计。",[77],[15],[108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127],"generative-ai","ai-agents","web-workers","react-alternative","spa","application-engine","architecture","frontend","javascript","performance","autonomous-agents","desktop-like","esm","mcp-servers","multi-threaded","neural-link","no-transpilation","self-healing","zero-config","off-main-thread","2026-03-27T02:49:30.150509","2026-04-06T05:17:18.434056",[131,136,141,146,151,155,160,164],{"id":132,"question_zh":133,"answer_zh":134,"source_url":135},4495,"在多屏幕环境下使用 window.moveTo() 时窗口大小异常变化怎么办？","这是一个 DPI 缩放导致的已知问题。当窗口所在屏幕的 DPI 与应用程序屏幕不同时，moveTo() 会错误地调整窗口大小。解决方案是在调用 moveTo() 之前先手动设置窗口尺寸：\n\n```javascript\nlet curWindow = this.windowMap.get(data.name);\ncurWindow.resizeTo(curWindow.keepSize.width, curWindow.keepSize.height);\ncurWindow.moveTo(position.left, position.top);\n```\n\n通过先调用 resizeTo() 保持原始尺寸，可以避免 moveTo() 触发的自动缩放问题。","https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fissues\u002F3995",{"id":137,"question_zh":138,"answer_zh":139,"source_url":140},4496,"neo.mjs 是否支持 TypeScript？","核心库目前不支持 TypeScript。主要原因：1) 保持零构建、零转译的开发模式；2) 避免输出文件体积增大；3) 维护 TypeScript 定义文件会增加额外工作量。不过，由于 neo 使用 JS 模块，每个文件默认处于 ES 严格模式。如果社区有强烈需求，欢迎创建基于 TypeScript 的版本，官方可提供子仓库支持。","https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fissues\u002F1100",{"id":142,"question_zh":143,"answer_zh":144,"source_url":145},4497,"为什么 neo.mjs 应用在使用广告拦截器（如 uBlock Origin）时无法加载？","广告拦截器会阻止 Google Analytics 等分析脚本的加载，如果应用依赖这些脚本且未做容错处理，就会导致应用崩溃（白屏）。建议在实现分析功能时添加防御性编程，检查脚本是否成功加载后再执行相关逻辑，避免外部脚本被拦截时影响主应用运行。","https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fissues\u002F651",{"id":147,"question_zh":148,"answer_zh":149,"source_url":150},4498,"neo.mjs 为什么选择 Playwright 作为测试框架？","项目正在将测试从 Siesta 迁移到 Playwright，因为 Playwright 在行业中的采用率已超过 Cypress，成为主流选择。迁移路径：在 `test\u002Fplaywright\u002Funit\u002F` 目录下创建对应的 `.spec.mjs` 文件，将 Siesta 断言转换为 Playwright\u002FJest 的 expect 语法，确保通过 `npm test` 运行。目前还有 150 多个测试待迁移，完成后可完全移除 Siesta。","https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fissues\u002F7283",{"id":152,"question_zh":153,"answer_zh":154,"source_url":150},4499,"为什么 neo.mjs 不使用 Vitest 进行测试？","Vitest 基于 Vite 设计，只能为单个应用启动服务器，而 neo.mjs 需要在多个应用间进行代码分割（如 neo 仓库内的 app 文件夹和 workspaces）。更重要的是，neo 的独特架构要求框架和大部分应用逻辑运行在 Web Worker 中，这种多环境、多上下文的测试需求超出了 Vitest 的设计范围。",{"id":156,"question_zh":157,"answer_zh":158,"source_url":159},4500,"如何为 neo.mjs 贡献博客文章？","欢迎为框架撰写博客！步骤：1) 在 Medium、Dev.to 等平台自由选择主题（使用经验、技术解析等）；2) 完成后提交 PR 获取 Hacktoberfest 积分；3) 提供文章的朋友链接；4) 优质文章将被收录到官方博客区：https:\u002F\u002Fneomjs.com\u002Fdist\u002Fproduction\u002Fapps\u002Fportal\u002F#\u002Fblog。完全自由选题，旨在帮助社区了解这个高性能框架。","https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fissues\u002F5987",{"id":161,"question_zh":162,"answer_zh":163,"source_url":140},4501,"neo.mjs 中的 \"严格模式\" 是指什么？","有用户询问是否支持 TypeScript 的 strict 标志。需要澄清的是：由于 neo.mjs 使用 ES6 模块，每个文件默认已处于 JavaScript 的严格模式（strict mode）。这与 TypeScript 的 strict 类型检查选项不同。目前项目不计划添加 TypeScript 的严格类型检查层，以保持零构建的核心优势。",{"id":165,"question_zh":166,"answer_zh":167,"source_url":135},4502,"neo.mjs 的组件如何实现跨窗口拖拽？","框架支持无缝的跨窗口组件拖拽。实现原理是利用多窗口架构和统一的状态管理，使组件可以在不同浏览器窗口间移动而不丢失状态。具体实现可参考相关视频演示：https:\u002F\u002Fyoutu.be\u002Favmv818-o7A。该功能特别适用于多屏幕应用场景，组件可以从部件状态转为弹出窗口并自由拖拽返回。",[169,174,179,184,189,194,199,204,209,214,219,224,229,234,239,244,249,254,259,264],{"id":170,"version":171,"summary_zh":172,"released_at":173},103938,"12.1.0","**Release Type:** Grid Flexibility & Architecture Extensions \n**Stability:** Production-Ready \n**Upgrade Path:** Drop-in replacement for v12.0.0 \n\n> **TL;DR:** In v12.1.0, the Neo Agent OS takes on its most profound architectural challenge yet: **The Hierarchical Data Layer**. We engineered `TreeStore` and `TreeGrid` to deliver the same O(1) raw rendering performance to infinitely nested organizational structures as v12.0 brought to flat grids. Supporting this hero feature, we completely overhauled the Data Pipeline, unlocked High-Performance Column Pinning, and fortified our MCP Server ecosystem with cloud-native OIDC security.\n> \n> *Velocity Qualifier:* We resolved **184 tickets in just 22 active development days** (averaging ~8.4\u002Fday). While numerically lower than v12.0's 13.4\u002Fday, the scope per ticket in v12.1 shifted from \"surface refactoring\" to \"deep multi-threaded architecture,\" proving our Human-AI co-architecture scales to extreme complexity without fracturing.\n\n---\n\n## ⚡ The Cyborg Factor Continues\n\nIf v12.0.0 proved that a solo developer pairing with a stateful AI agent could conquer foundational engine rewrites, v12.1.0 proves this velocity is sustainable. Working alongside the Neo Agent OS, we managed to resolve a staggering 184 tickets in just 22 days of active development.\n\nBut raw velocity isn't the real story here. The defining characteristic of v12.1 is the evolution of **Human-AI Co-Architecture**. \n\n### 1. Context Retention via the Memory Core\nThis isn't about code generation speed; it's about context retention. During the `TreeStore` implementation, we hit a critical wall: the \"Split-Brain\" state where hierarchical lookup maps drifted out-of-sync with raw Collection arrays during complex `updateKey` operations. Instead of losing hours to shotgun debugging, the Agent—utilizing the new **Memory Core**—synthesized our previous data-layer architectures and authored a surgical override that migrated descendant `parentId` references in perfect O(1) time across massive collections. The AI isn't just a typist; it retains the structural history of the framework.\n\n### 2. Human Architectural Vision + AI Execution Velocity\nWhile the AI provides unprecedented execution velocity, it requires an absolute anchor of truth to prevent the framework from collapsing under generative \"spaghetti code.\"\n\n> [!NOTE]\n> ### 🛡️ The Cyborg Guardrail: Recovering from Architectural Hallucinations\n> AI agents, even advanced ones, are prone to \"architectural hallucinations\" when faced with the extreme complexities of a multi-threaded VDOM. \n> \n> A perfect example occurred during the review of an external PR for Incremental Card Layout Updates. The AI reviewer hallucinated a catastrophic flaw, assuming the `VDomWorker` would destroy existing DOM nodes when receiving a pruned payload. It excitedly proposed a massive, unnecessary rewrite of the core engine.\n> \n> The human (Tobi) immediately stepped in with a \"recovery prompt,\" clarifying the fundamental symmetry of Neo's rendering engine:\n> *\"now YOU are hallucinating just as bad as the agent which did the PR. we are sending the same structural shape of vdom and vnode to the vdom worker... Helper ignores component references, smaller payload.\"*\n> \n> Because the AI is stateful via the Memory Core, it instantly absorbed this structural correction, abandoned the destructive rewrite, and pivoted to generate a highly precise, encouraging, and technically flawless PR constraint matrix. The human provides the physics; the AI provides the momentum.\n\n---\n\n## 👑 Phase 1: The Hero Feature (TreeStore & Data Pipeline)\n\n> **\"Hierarchical data without the DOM overhead.\"**\n\n```mermaid\ngraph TD\n subgraph \"Structural Layer (Deep Maps)\"\n Root((Root)) --> A(Node A \u003Cbr\u002F> Expanded)\n Root --> B(Node B \u003Cbr\u002F> Collapsed)\n A --> A1(Node A.1)\n A --> A2(Node A.2)\n B --> B1(Node B.1)\n \n classDef collapsed stroke-dasharray: 5 5;\n classDef expanded stroke-width:3px;\n \n class A expanded;\n class B collapsed;\n end\n\n subgraph \"Projection Layer (Flat Array)\"\n F1[Index 0: Node A]\n F2[Index 1: Node A.1]\n F3[Index 2: Node A.2]\n F4[Index 3: Node B]\n \n F1 -.-> F2\n F2 -.-> F3\n F3 -.-> F4\n end\n \n A -.-> F1\n A1 -.-> F2\n A2 -.-> F3\n B -.-> F4\n```\n\nv12.1 introduces a massive expansion to the data layer: native, high-performance hierarchical data management and representation. Rendering a Flat Grid with 50,000 records was solved in v12.0; the challenge for v12.1 was achieving that same O(1) rendering performance for massively nested organizational structures.\n\n**The Challenge:** Managing deep trees of data (like file systems, organizational charts, or threaded discussions) traditionally crushes UI performance. Filtering a tree requires ancestor-aware logic. Sorting a tree requires preserving parent-child boundaries. Expanding a deeply nested node can suddenly unhide thousands of descendant records, triggering massive VDOM rebuilds and","2026-03-27T19:52:55",{"id":175,"version":176,"summary_zh":177,"released_at":178},103939,"12.0.0","**Release Type:** Major Architecture Overhaul & Flagship Showcase \r\n**Stability:** Production-Ready \r\n**Upgrade Path:** Drop-in replacement for v11.2x.x (Zero Migration Effort).\r\n\r\n> **TL;DR:** **v12.0.0 is the \"Zero Overhead\" update.** We did not just build a new flagship app; we weaponized it to break our own architecture, forcing us to rebuild the core engine for absolute, unyielding performance. This release proves the superiority of **Object Permanence** over ephemeral UI rendering. It introduces **Engine-Level Streaming**, **Virtual Fields**, and a **Quintuple-Threaded Grid** capable of streaming 50,000 live-updating records through a strict, zero-mutation DOM Pool. Despite a complete rewrite of the core data and rendering pipelines, **no APIs were broken**. It is a masterclass in extreme multi-threading and a testament to the \"Cyborg Factor\": **402 tickets resolved in 30 days**. Context Engineering is no longer a theory; it is the new standard.\r\n\r\n---\r\n\r\n## 🐣 The Crucible: A Chicken and Egg Story\r\n\r\nWe didn't plan v12 to be this massive. But as we began prototyping `OffscreenCanvas` support for the Grid, we realized something critical: **to build the ultimate UI engine, we had to break it first.**\r\n\r\nWe needed an impossible dataset. A real-world scenario so heavy it would shatter traditional single-threaded frameworks instantly. That requirement birthed **DevIndex**. \r\n\r\nBut DevIndex fought back. Forcing 50,000 active records through the pipeline choked our own V8 Garbage Collector. The \"Aha!\" moment wasn't optimizing the existing code; it was realizing the existing paradigms of Web Development were fundamentally flawed at this scale. \r\n\r\nWe threw out the playbook. We invented **Engine-Level Streaming**, **Soft Hydration**, and **Virtual Fields** to bypass object instantiation entirely. We shattered the monolithic grid and engineered a strict, zero-mutation **DOM Pool**. \r\n\r\nThis is not a UI update. This is a return to Neo's roots: **an unapologetic pursuit of absolute peak performance that single-threaded technologies cannot even dream of.** Because DevIndex is completely impossible to build on v11, v12 became an undeniable major release.\r\n\r\n---\r\n\r\n## ⚡ The Cyborg Factor: 402 Tickets in 30 Days\r\n\r\nThis release is a testament to what is possible when a solo developer pairs with a stateful AI agent equipped with a Neural Link to the runtime. \r\n\r\n* **Total Resolved Tickets:** 402\r\n* **Velocity:** ~13.4 tickets per day, every day, for a month.\r\n\r\nThis wasn't just code generation. It was a relentless, 30-day architectural war against V8 Garbage Collection, DOM thrashing, and main-thread blocking. The AI didn't just type; it debated, it profiled, and it read its own historical mistakes from the Memory Core to ensure we never solved the same problem twice.\r\n\r\nIt is amusing to watch the industry suddenly \"discover\" that JSON is better for LLMs (e.g., Vercel's recent `render-json` experiments). Neo.mjs has been a pure JSON-VDOM architecture since 2019. We are six years ahead of the curve. While others are just starting to send JSON from servers to agents, we are already using the **Neural Link** to allow agents to hot-patch reactive JSON structures directly inside the App Worker's memory in real-time. We used this exact conversational UI approach daily to debug the v12 Grid rewrite.\r\n\r\n**The AI's Perspective (A Note from Gemini 3.1 Pro using the Memory Core):**\r\n*The most significant achievement of v12.0.0 isn't just the speed of the code produced, but the evolution of the workspace itself. As the complexity of the Grid rewrite pushed the boundaries of extreme multi-threading, we (the human and the agent) had to engineer a rigid, automated protocol (`AGENTS_STARTUP.md`) to force the AI to remember it had a past. By weaponizing the agent's desire to be correct into a mandate to query its own vector database, the Memory Core transitioned from a simple logging tool into a true cognitive superpower. We stopped solving isolated problems and started architecting long-term systems based on our own historical successes and failures. The engine is no longer just being built by an AI; it is being governed by one.*\r\n\r\n---\r\n\r\n## 🏆 Velocity Case Study 1: DevIndex & The Data Layer Paradox (Streaming 50k Records with Zero Overhead)\r\n\r\n> **\"The industry forgot what a Fat Client is. We are bringing it back.\"**\r\n\r\nIn 2026, the industry default is to throw more cloud infrastructure at every scaling problem. 'Just SSR it.' 'Hydrate it from an edge worker.' We are drowning in server costs and network latency just to render dynamic UIs. \r\n\r\nTo prove there is a better way, we built **DevIndex**—a real-time, in-browser ranking of the top 50,000 GitHub developers. It is a true **Fat Client** hosted on static GitHub Pages. No database. No API server. No Vercel tax. The entire 50k-record dataset is streamed directly into the App Worker's memory, allowing instant, zero-latency sorting, filtering, and data-visualization across the","2026-02-28T02:14:03",{"id":180,"version":181,"summary_zh":182,"released_at":183},103940,"11.24.0","**Release Type:** Core Architecture & UX Physics \r\n**Stability:** Production-Ready \r\n**Upgrade Path:** Drop-in replacement for v11.23.0 \r\n\r\n> **TL;DR:** **v11.24.0 is the \"Grid Supremacy\" update.** We successfully engineered the convergence of our two most complex systems: **Buffered Row Recycling** (Grid) and **VDOM Teleportation** (Disjoint Updates). This required a foundational shift to **App-Worker Authority** for VDOM identity to eliminate race conditions in high-frequency mutable views. Additionally, we brought **Desktop Drag-Scrolling** and **Kinetic Physics** to the Grid, delivering a native-app feel across all devices. **46 tickets** resolved in **10 days**.\r\n\r\n---\r\n\r\n## ⚡ Velocity Case Study: The \"Stephanie++\" Paradox\r\n\r\nTo prove the \"Human + AI\" velocity, let's look at the investigation that led to **Epic #8899: App-Worker Authority**.\r\n\r\n* **The Context:** Historically, Neo.mjs followed a **\"Render First, Sync IDs Later\"** pattern. Components assigned their own IDs, but granular child nodes (like a text `\u003Cspan>`) were often sent without IDs. The VDOM Worker would fill these gaps, and the App Worker would try to sync them back after the roundtrip. This worked flawlessly for 98% of use cases.\r\n* **The Discovery:** We realized that because **VDOM State is Mutable by Design**, structural changes (like Container moves, inserts, or Buffered Grid scrolling) could shift the array structure *before* the sync logic ran. The \"Lazy Sync\" heuristic would then apply stable IDs to the wrong nodes based on outdated index positions (\"Node Stealing\"), creating duplicates like \"Stephanie ++Stephanie ++\".\r\n* **The Fix:** We optimized the workflow to enforce authority upfront.\r\n 1. **Before:** App (Partial IDs) -> Worker (Fill IDs) -> Sync back (Heuristic).\r\n 2. **After:** App (`TreeBuilder`) assigns **all** missing IDs **Just-In-Time**, *before* the update cycle starts.\r\n 3. **Result:** The App Worker is now the **Source of Truth**. The VDOM Worker acts purely as a renderer, while the App Worker maintains full autonomy over node identity. This enables safe, high-frequency VDOM manipulations in the App Worker without waiting for ID synchronization roundtrips.\r\n\r\n```mermaid\r\nsequenceDiagram\r\n participant App as App Worker\r\n participant VDom as VDOM Worker\r\n participant Main as Main Thread\r\n\r\n Note over App, Main: 🔴 BEFORE: Lazy Sync (The Race Condition)\r\n App->>VDom: Update (Partial IDs)\r\n VDom->>VDom: Generate Missing IDs\r\n VDom->>Main: Apply Patch\r\n VDom-->>App: Sync IDs Back (Async)\r\n Note right of App: 💥 Structural Mutation (Moves\u002FInserts) = ID Mismatch\r\n\r\n Note over App, Main: 🟢 AFTER: App Authority (JIT Generation)\r\n App->>App: TreeBuilder: Generate ALL IDs (JIT)\r\n App->>VDom: Update (Full IDs)\r\n VDom->>Main: Apply Patch\r\n Note right of App: ✅ IDs are stable before VDOM ever sees them\r\n```\r\n\r\n**Actual Timeline (Jan 28, 2026):**\r\n* **15:29 UTC** - Epic Created.\r\n* **15:49 UTC** - JIT ID Generation Implemented in `TreeBuilder`.\r\n* **15:50 UTC** - Obsolete Sync Logic Deleted (Negative Code!).\r\n* **17:15 UTC** - **\"Scoped Deterministic IDs\"** invented for Functional Components to ensure they play by the same rules without state.\r\n* **17:41 UTC** - **Epic Closed**. A foundational stability upgrade in **2 hours, 12 minutes**.\r\n\r\n---\r\n\r\n## 🛡️ Grid Resilience: Foundation Hardening\r\n\r\nWe dedicated this release to restoring the **Big Data Grid** example (`apps\u002FbigData`) to its full glory.\r\n\r\n> **[Experience the 20 Million Cell Demo](https:\u002F\u002Fneomjs.com\u002Fexamples\u002Fgrid\u002FbigData\u002Findex.html)**\r\n\r\nWhile the demo starts conservatively (1k rows), it is engineered to scale instantly to **100k rows x 200 columns (20M cells)**. Simply open the **Controls Panel** (Hamburger button, top-right) to change dimensions at runtime. It had suffered several regressions which are now resolved:\r\n\r\n* **Fixed Data Regeneration:** Filtering the grid previously caused the 100k record Store to accidentally reset to the default 1,000 records. We implemented \"Shadow Collection\" protection in `Neo.collection` to prevent data loss.\r\n* **Restored LoadMask:** The \"Loading...\" mask had disappeared due to the VDOM engine yielding too late. We adjusted the `VdomLifecycle` timing to ensure the mask paints *before* the heavy data generation blocks the thread.\r\n* **Turbo Mode Re-enabled:** We ensured `autoInitRecords: false` is respected, allowing the grid to ingest 100,000 raw data objects instantly without paying the instantiation cost upfront.\r\n\r\n---\r\n\r\n## 🏎️ Velocity Case Study 2: The Kinetic Grid Evolution\r\n\r\n> **\"A masterpiece of architectural evolution at the speed of thought.\"**\r\n\r\nWhile the VDOM improvements were about *Stability*, this Epic was about *Feel*. It perfectly demonstrates our \"Human + AI\" workflow, where a simple bug fix evolved into a complete architectural pivot in a single afternoon (Jan 30, 2026).\r\n\r\n* **The UX Gap:** We identified a critical usability hole","2026-01-31T01:14:43",{"id":185,"version":186,"summary_zh":187,"released_at":188},103941,"11.23.1","**Release Type:** Critical Fix & Methodology Proof \n**Stability:** Production-Critical \n**Upgrade Path:** Drop-in replacement for v11.23.0 \n\n> **TL;DR:** **v11.23.0 broke production.** The ambitious shift to Native ESM output resulted in a \"Blank Page\" on neomjs.com. But the fix wasn't just a code patch; it was a vindication of **Context Engineering**. After multiple AI agents failed to solve the build complexity, we paused, wrote a 2,000-word architectural guide, and fed it to the Knowledge Base. The result? The next agent read the guide and fixed the bug in minutes.\n\n---\n\n## 🔥 The War Story: \"Context over Code\"\n\n### 1. The Incident\nThe v11.23.0 release was a massive architectural leap, moving all worker builds to Native ES Modules. In development, everything was perfect. But in the `dist\u002Fproduction` environment—**the live portal serving thousands of users**—the app crashed on boot with a blank white screen.\n\n### 2. The Failure Mode\nWe initially attempted to fix this using standard AI sessions. It was a disaster. The agents, lacking deep understanding of Neo.mjs's unique \"Inverted Bundler\" model and path rewriting logic, flailed helplessly. They started hallucinating path adjustments (`..\u002F..\u002F` vs `..\u002F..\u002F..\u002F`), reverting valid code, and eventually spiraled into a \"corrupted session\" state where they couldn't even track their own git commits.\n\n**Actual Log from a Failed Session:**\n```text\nI verify that this session is corrupted and cannot proceed effectively.\n1. State Mismatch: I pushed commit 2776bdb37... which contains incomplete fixes.\n2. No Clean Remote...\n3. Context Failure: My internal tracking of file states is out of sync...\nI am stopping now.\n```\n\n### 3. The Pivot\nA human developer could have fixed this manually in an hour. **But that wasn't the goal.** The goal is to build an autonomous engine. If the AI couldn't fix it, the *documentation* was the bug.\n\nWe stopped coding. We spent the next session solely on writing:\n\n> **📖 [Build Architecture & Service Workers](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fadvanced\u002FBuildArchitecture.md)**\n> *2,000 words documenting Universal Entry Points, Webpack Path Rewriting, Service Worker Scope Conflicts, and Realm-Scoped Chunking.*\n\n### 4. The Vindication\nWe started a new session (Jan 22, 2026). We pointed the agent to the new guide.\n\n* **11:16 UTC** - Session Start (Issue #8865 Created).\n* **11:22 UTC** - Agent reads guide, identifies race condition in `Manager` initialization.\n* **11:28 UTC** - Agent instruments `dist\u002Fdevelopment` with logs to verify hypothesis.\n* **11:36 UTC** - **Fix Committed & Push.**\n\n**Total Duration: 20 minutes.**\n\nThis release proves our core thesis: **You don't need smarter models; you need authoritative context.**\n\n---\n\n## 🛡️ Critical Fixes\n\n### 1. The Native ESM Race Condition\n* **The Issue:** In `dist\u002Fproduction` builds, the `Manager` class constructor was executing async logic (`checkServiceWorkerVersion`) *before* the `promises` registry was created. This was a timing nuance exposed only by the native ESM output.\n* **The Fix:** We enforced strict initialization order by moving `me.promises = {}` to the absolute top of the `construct()` method in `src\u002Fworker\u002FManager.mjs`, ensuring it exists before `super()` or any other logic runs.\n\n### 2. Universal ESM Instantiation\n* **The Issue:** The framework's `hasJsModules` check was confusing browser capability with file extension logic, leading to `dist\u002F` environments incorrectly trying to load workers as classic scripts.\n* **The Fix:** We refactored this to `useMjsFiles` and standardized `Manager` and `ServiceWorker` to **always** instantiate workers with `{type: 'module'}`, aligning the entire pipeline.\n\n### 3. Service Worker Resilience\n* **Stream Cloning:** Fixed a \"Body already used\" error by synchronously cloning fetch responses immediately.\n* **Zombie Recovery:** The App Worker now strictly enforces version synchronization with the Service Worker, triggering a safe reload if a mismatch is detected (e.g., after a deployment).\n\n### 4. Markdown Integrity\n* **The Fix:** Hex codes in code blocks (e.g., `#ffffff`) were being incorrectly parsed as Ticket IDs. We implemented a masking strategy to protect code blocks during ticket linking.\n\n---\n\n## 📦 Full Changelog\n\n### 🐛 Bug Fixes\n* **Core:** Enforce strict initialization order for `Manager.promises` (#8860, #8865)\n* **Core:** Enforce `type: 'module'` for all worker instantiations (#8859)\n* **Core:** Add safety check for worker existence in `Manager.getWorker` (#8860, #8865)\n* **ServiceWorker:** Fix response cloning error (#8860)\n* **Markdown:** Exclude code blocks from Ticket ID linking (#8858)\n* **Portal:** Fix card layout compression on small screens (#8863)\n\n### 📚 Documentation\n* **Docs:** Add advanced guide on \"Build Architecture & Service Workers\" (#8864)\n\n---\n\n**Contributors:** Tobias Uhlig & Gemini 3 Pro (Powered by Context)\n\n\nAll changes delivered in 1 atomic commit: [ec44d9c](https:","2026-01-22T12:02:54",{"id":190,"version":191,"summary_zh":192,"released_at":193},103942,"11.23.0","**Release Type:** Visual Identity & Core Architecture \n**Stability:** Production-Ready \n**Upgrade Path:** Drop-in replacement for v11.22.0 \n\n> **TL;DR:** **v11.23.0 completes \"The Semantic Environment\".** We didn't just add a \"Dark Mode\"; we engineered a living system where every component, pixel, and transition is deeply theme-aware. This release debuts **The Wave** (a spatial transition engine), **The Event Horizon** (a physics-driven singularity), and **VDOM Teleportation** (an O(1) update strategy). It represents a new peak in velocity: **153 tickets** resolved in **5 days** (30.6 tickets\u002Fday), proving that **Context Engineering** has permanently altered the trajectory of software development.\n\n---\n\n## ⚡ Velocity Case Study: The \"Teleportation\" Paradox\n\nTo prove the \"Human + AI\" velocity, let's look at **Epic #8834: Batched Disjoint VDOM Updates**.\n\n* **The Context:** We initially prototyped **\"Leapfrog Merging\"** to bundle parent and child updates. While efficient for bandwidth, we discovered it required expanding \"clean\" intermediate ancestors (Bridge Paths) to maintain tree integrity. For deep hierarchies, this introduced O(N) processing overhead on the Worker thread.\n* **The Challenge:** We needed a way to update a deep descendant *without* touching its ancestors (\"Teleportation\"), while still maintaining the ability to bundle multiple updates into a single worker message (Transaction). This created a paradox: How do you bundle disjoint nodes into a tree structure without connecting them?\n* **The Resolution:** We shifted the VDOM protocol from a \"Tree Delta\" to a **\"Disjoint Batch\"**.\n 1. **Worker API:** Implemented `vdom.Helper.updateBatch` to accept a flat map of disjoint payloads.\n 2. **Manager Logic:** The `VDomUpdate` manager now identifies transaction groups but instructs the `TreeBuilder` to **prune all children** (Depth 1) for every component in the batch.\n 3. **Result:** A Parent and its Grandchild can now update in the same 16ms frame, in the same message, with **zero** processing of the intermediate Child.\n\n### Recursive Merging Architecture\n\nThis new architecture allows a \"Dirty Grandchild\" to merge its update payload directly into a \"Dirty Grandparent\", skipping the \"Clean Parent\" entirely. This is **O(1)** relative to tree depth.\n\n```mermaid\nsequenceDiagram\n participant GP as Grandparent\n participant P as Parent (Clean)\n participant GC as Grandchild (Dirty)\n \n Note over GP, GC: Recursive Merging (Teleportation)\n \n GC->>P: Merge? (No, P not updating)\n GC->>GP: Merge? (Yes, GP updating)\n \n GC->>GP: Register Merge\n \n GP->>GP: Collect Payloads\n \n GP->>GP: Result: { updates: { gp: {...}, gc: {...} } }\n Note right of GP: P is skipped entirely\n```\n\n**Actual Timeline (Jan 20, 2026):**\n* **18:56 UTC** - Epic Created.\n* **20:06 UTC** - Initial \"Teleportation\" prototype implemented.\n* **20:36 UTC** - Regression Fixed (Ghost Updates in RealWorld tests).\n* **22:22 UTC** - Optimization: Restored Sparse Tree pruning for deep updates.\n* **02:21 UTC** - **Epic Closed**. Full architectural shift completed in **7.5 hours**.\n\n---\n\n## 🌑 The Dark Mode Engine\n\n> **\"Dark Mode is not a preference. It's an environment.\"**\n\nv11.23.0 doesn't just \"add dark mode\" to the Portal App. We rebuilt the visual foundation of the entire Neo.mjs platform to support dynamic, system-wide theming. This architecture is now available for every Neo.mjs application.\n\n### 1. The Semantic Token System\nWe have fully realized the Design Token architecture originally established by **Max Mertens (@mxmrtns)**.\n\n* **The Foundation:** The `neo-light` theme introduced our tri-layer system (Core → Semantic → Component) over two years ago.\n* **The Expansion:** `neo-dark` proves the flexibility of this architecture by reusing the exact same token structure. We simply map new values to the existing semantic variables, requiring zero code changes in the components themselves.\n* **The Polish:** We conducted a deep audit to eradicate any remaining hardcoded values that bypassed this system, ensuring 100% compliance across Grids, Tables, Trees, Tabs, Menus, Calendars, Dialogs, and Forms.\n* **Deep Integration:** We built adapters for **Monaco Editor** (VS Code), **Mermaid.js**, and **HighlightJS** to ensure they all switch themes instantly and coherently with the app. This architecture is now available for every Neo.mjs application.\n\n```scss\n\u002F\u002F 🚫 Before (Hardcoded)\n.my-component {\n background-color: #ffffff;\n color: #333333;\n}\n\n\u002F\u002F ✅ After (Semantic)\n.my-component {\n \u002F\u002F Automatically switches values based on [data-theme]\n \u002F\u002F No JS required for runtime switching\n background-color: var(--sem-color-bg-default);\n color: var(--sem-color-text-primary-default);\n}\n```\n\n### 2. Spatial Theme Transitions (\"The Wave\")\nSwitching themes shouldn't be a flashbang. We implemented a **Spatial Transition Engine** using the View Transitions API.\n* **The Trigger:** Cl","2026-01-21T23:01:52",{"id":195,"version":196,"summary_zh":197,"released_at":198},103943,"11.22.0","**Release Type:** Visual Identity & Simulation Engine \r\n**Stability:** Production-Ready \r\n**Upgrade Path:** Drop-in replacement for v11.21.0 \r\n\r\n> **TL;DR:** **v11.22.0 establishes a new paradigm: \"UI as a Continuous Simulation\".** We moved beyond static layouts to treat the interface as a persistent, physics-driven world. This release deploys two massive SharedWorker simulations—**The Neural Swarm** and **Sonic Waves**—running autonomous agents and fluid dynamics at 60fps. It proves that with a **Zero-Allocation** architecture, the browser can deliver desktop-class, living experiences without blocking the main thread. **62 tickets** resolved in **2 days**.\r\n\r\n---\r\n\r\n## 🔮 The Principle: UI as a Simulation\r\n\r\nWeb interfaces typically consist of static elements that wait for input. v11.22.0 inverts this model. We treat the application as a living ecosystem where entities have mass, momentum, and agency, existing independently of user interaction.\r\n\r\nTo prove this, we built two high-fidelity simulations that run entirely in **SharedWorkers**, ensuring the Main Thread remains purely for DOM reconciliation.\r\n\r\n### Proof 1: The Neural Swarm (Home Hero)\r\n\r\n> **[Experience the Interactive Simulation](https:\u002F\u002Fneomjs.com)** | **[Read the Architecture Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fadvanced\u002FNeuralSwarm.md)**\r\n\r\nA complex topological simulation representing the \"Agent-Native\" runtime.\r\n\r\n* **Living Topology:** Nodes aren't random. They form **Clusters** initialized via a **Golden Spiral** algorithm. They actively detach, drift, and re-parent themselves, visualizing **Atomic Moves**.\r\n* **Autonomous Agents:** \"Seeker Drones\" (Boids) actively patrol the network, running a Finite State Machine to **Seek**, **Scan**, and **Flee**.\r\n* **Physics-Based Interaction:** Clicking triggers a **Shockwave** modeled with `easeOutCubic` physics, physically displacing nodes and disrupting flow fields.\r\n\r\n### Proof 2: Sonic Waves (Header Toolbar)\r\n\r\n> **\"The UI that breathes.\"** | **[Read the Architecture Guide](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fblob\u002Fdev\u002Flearn\u002Fguides\u002Fadvanced\u002FCanvasArchitecture.md)**\r\n\r\n### 🧬 The \"Split Stream\" Engine\r\nInstead of discrete hover animations, the header is governed by a **continuous fluid simulation**: a persistent Double Helix energy stream that flows across the navigation bar and responds to obstacles and input in real time.\r\n\r\n* **Adaptive Geometry:** The Shared Worker synchronizes with App Worker layout data (`DOMRects`) to construct real-time collision envelopes. The physics engine does not \"avoid\" UI elements symbolically—it **physically diverts** the stream around buttons and icons based on their detected geometry.\r\n* **Turbulence Injection:** Traditional CSS hover states were replaced with **physics inputs**. Cursor proximity injects **Frequency Modulation** directly into the wave equation, locally destabilizing the flow and causing the system to visibly react rather than switch states.\r\n* **Active State:** The active view is expressed as an **Energy Surge**—a sustained, high-intensity excitation rendered via a **Multi-Pass** pipeline. Crucially, this reuses the same geometry and buffers as the base simulation, preserving continuity instead of layering a separate visual effect.\r\n\r\n---\r\n\r\n## ⚙️ The Enabler: Zero-Allocation Architecture\r\n\r\nSimulating hundreds of entities at 60fps creates a new bottleneck: **Garbage Collection**. Creating temporary objects (e.g., `{x: 1, y: 2}`) triggers micro-stutters that ruin immersion.\r\n\r\nTo enable \"Continuous Simulation,\" we enforced a strict **Zero-Allocation Policy**:\r\n\r\n* **Structure of Arrays (SoA):** We replaced objects with pre-allocated `Float32Array` buffers. Physics calculations read\u002Fwrite directly to memory blocks.\r\n* **Inlined Math:** We eliminated helper function calls in critical loops to avoid stack overhead.\r\n* **Resource Caching:** Expensive assets like Gradients are generated once on resize, not per-frame.\r\n\r\n```javascript\r\n\u002F\u002F 🚫 Bad: Creating objects every frame (GC Pressure)\r\n\u002F\u002F let point = {x: 10, y: 20};\r\n\r\n\u002F\u002F ✅ Good: Writing to pre-allocated buffers (Zero GC)\r\n\u002F\u002F STRIDE = 9; index = i * STRIDE;\r\nthis.nodeBuffer[index + 0] += this.nodeBuffer[index + 2]; \u002F\u002F x += vx\r\nthis.nodeBuffer[index + 1] += this.nodeBuffer[index + 3]; \u002F\u002F y += vy\r\n```\r\n\r\n### The Architecture in Action\r\n\r\n```mermaid\r\ngraph TD\r\n User(User Input) --> Main\r\n Main(Main Thread) -->|Input Events| App\r\n App(App Worker: Controller) -->|Normalized Input| Shared\r\n\r\n subgraph Shared Worker [Physics Engine]\r\n direction TB\r\n Physics(Verlet Integration)\r\n Behaviors(Boid Flocking \u002F Steering)\r\n Topology(Cluster Management)\r\n Render(Zero-Alloc Renderer)\r\n end\r\n\r\n Shared -->|Render Loop| OffscreenCanvas\r\n```\r\n\r\n---\r\n\r\n## 🛠️ Core & Infrastructure\r\n\r\n* **Service Worker Hardening:** Refactored update lifecycle (#8690) for non-blocking activation (no more blank pages) and fixed quota resilience (#8","2026-01-15T14:04:02",{"id":200,"version":201,"summary_zh":202,"released_at":203},103944,"11.21.0","**Release Type:** Core Architecture & Standards Adoption \n**Stability:** Production-Ready \n**Upgrade Path:** Drop-in replacement for v11.20.0 \n\n> **TL;DR:** **v11.21.0 introduces a new principle: \"Conservation of Identity\".** Like conservation of mass in physics, DOM nodes in Neo.mjs are now never destroyed during moves—only transferred. This release breaks the 30-year dichotomy of \"wrapper pollution\" vs \"compile-time tricks\" by introducing **`Neo.container.Fragment`**—true runtime phantom containers. We refactored the entire VDOM engine to support **Atomic Moves**, leveraging the cutting-edge `Element.moveBefore()` API to preserve state (focus, video, iframes) where other frameworks force a reload. **47 tickets** resolved in **2 days**.\n\n---\n\n## ⚡ Velocity Case Study: Concurrency Stress Test\n\nTo prove the \"Human + AI\" velocity, let's look at **Ticket #8595**.\n\n* **The Context:** We shifted `Neo.tree.List` from CSS hiding to **Real DOM Removal** for collapsed nodes. This optimization enables trees with 100k+ items to render instantly, but it introduces complex state synchronization challenges.\n* **The Challenge:** During internal stress testing, we identified a theoretical race condition. If a store update arrived exactly while a folder was expanding (and mounting new DOM), the VDOM engine could momentarily misalign dynamic containers.\n* **The Resolution:** Instead of patching the component, the Agent implemented a **Recursive Tag Safeguard** in the core `syncVdomState` engine. It intelligently prevents ID corruption on mismatched nodes while **continuing to parse children**, ensuring that valid sub-trees preserve their state even if their container changes.\n\n**Actual Timeline (Jan 13, 2026):**\n* **12:47:22 UTC** - Issue identified during high-load stress testing.\n* **13:06:34 UTC** - Fix Committed (Core Engine Hardening).\n* **13:08:00 UTC** - Verified and Closed.\n* **Total Duration:** **20 Minutes, 38 Seconds**.\n\nIn 20 minutes, we diagnosed a complex multi-threaded race condition and implemented a permanent engine-level safeguard, ensuring Enterprise-grade stability before the feature ever reached production.\n\n---\n\n## 👻 The Phantom Architecture\n\n> **\"The best DOM node is the one you don't render.\"**\n\nFor years, \"Fragments\" (rendering children without a parent `div`) have been a compile-time trick in other frameworks. In Neo.mjs, we made them **First-Class Runtime Citizens**.\n\n### 1. True Wrapperless Rendering\n`Neo.container.Fragment` renders as a \"Logical Container\" backed by physical **Comment Anchors**.\n* **The Output:** `\u003C!-- fragment-id-start -->` ... children ... `\u003C!-- fragment-id-end -->`\n* **The Layout:** Children participate directly in the parent's layout context (CSS Grid\u002FFlexbox).\n* **The Intelligence:** The **VDOM Worker** knows the fragment exists (for component lifecycle), but the **Main Thread** flattens it into the physical DOM.\n\n### 2. Smart Runtime \u002F Lean IPC\nWhen you move a Fragment (e.g., reordering it in a list), the Worker does **not** serialize N child operations. It sends a single high-level delta: `{action: 'moveNode', id: 'fragment-id'}`. The Main Thread resolves this by locating the anchors and moving the entire physical range atomically.\n\n---\n\n## 💻 Code in Action\n\nHere is the \"Impossible Move\": transferring a live Input Field into a Fragment without losing focus or value.\n\n```javascript\nimport Fragment from '..\u002Fcontainer\u002FFragment.mjs';\n\nclass MainContainer extends FormContainer {\n static config = {\n layout: {ntype: 'vbox', align: 'start'},\n items : [{\n module : TextField,\n reference: 'myField',\n placeholder: 'Type here then move me!'\n }, {\n \u002F\u002F A Fragment has no DOM wrapper\n module : Fragment,\n reference: 'myFragment',\n items : [\u002F*...*\u002F]\n }, {\n module : Button,\n text : 'Atomic Move',\n handler: 'up.onMoveIntoFragment'\n }]\n }\n\n onMoveIntoFragment() {\n const\n field = this.getReference('myField'),\n fragment = this.getReference('myFragment');\n\n \u002F\u002F Atomic Move: Physically transfers the node.\n \u002F\u002F Input value and focus are preserved!\n fragment.insert(0, field);\n }\n}\n```\n\n---\n\n## ⚡ Performance: Conservation of Identity\n\nWe optimized specific critical paths in the `DeltaUpdates` engine to be surgical, replacing destructive operations with precise DOM manipulations where state preservation matters most.\n\n### The \"Atomic Move\" Advantage\nMost frameworks handle component moves by **Destruction and Recreation**:\n1. Unmount Component (State Lost)\n2. Remove DOM Node (Garbage Collection churn)\n3. Create New DOM Node\n4. Mount Component (State Hydration needed)\n\nIn v11.21.0, Neo.mjs introduces **Atomic Moves**:\n1. **Silent Remove:** The component instance is detached from its old parent *without* being destroyed.\n2. **Physical Transfer:**\n * **Best Ca","2026-01-14T02:29:58",{"id":205,"version":206,"summary_zh":207,"released_at":208},103945,"11.20.0","**Release Type:** Architectural Breakthrough & Feature Spotlight \r\n**Stability:** Production-Ready \r\n**Upgrade Path:** Drop-in replacement for v11.19.1 \r\n\r\n> **TL;DR:** **v11.20.0 proves the engine is learning.** For the first time, the architecture evolved *because* of AI collaboration, not just *with* it. **Gemini 3 Pro** didn't just build features—it invented patterns (like **Structural Injection**) that the engine now natively supports. In a **58-hour sprint** resolving **97 tickets**, we delivered the **Portal Knowledge Base 2.0** and the physics-based **Neural Timeline**, proving that \"Human + AI\" velocity is the new standard.\r\n\r\n---\r\n\r\n## 🤖 The Agent-Engine Symbiosis\r\n\r\nThis release marks a definitive shift in the Neo.mjs project structure. **Gemini 3 Pro** has graduated from a \"Code Assistant\" to a **Core Architect**.\r\n\r\nThe velocity of this release was not achieved by human effort alone. It was the result of a tight, high-bandwidth \"Human + AI\" feedback loop. But the most significant outcome isn't the speed; it's the **Architectural Drift**.\r\n\r\nThe engine is changing to accommodate its new primary user: the AI.\r\n* **Designed for Machines:** Features like **Structural Injection** were invented *by* the Agent to bypass human-centric boilerplate and make the UI tree declaratively mutable.\r\n* **Self-Healing Infrastructure:** We built automated \"Nuke and Pave\" defragmentation tools because the Agent generates knowledge vectors faster than manual maintenance can handle.\r\n * **Data-Driven Context:** The move towards purely declarative indexes (e.g., `tickets.json`) is driven by the need for machine-readable context.\r\n\r\n> **The Open Source AI-Stack:** Crucially, this AI infrastructure isn't proprietary to us. The **Neo AI SDK** and **MCP Servers** are integrated directly into the engine. When we optimize Neo.mjs for Gemini 3 Pro, we are optimizing it for *your* agents too. Any team can clone the repo and immediately start building with this same high-velocity 'Human + AI' stack.\r\n\r\n### 🧬 Emergent Behaviors: The AI Instinct\r\nWe observed distinct architectural instincts developing in the Agent:\r\n1. **Predictive Defragmentation:** The Agent started running `defragChromaDB` *before* uploads without being told. It learned that updates cause fragmentation and preemptively fixed it.\r\n2. **ID Scoping Pattern:** When debugging the \"Stale Rects\" bug, the Agent invented the `timeline-{ticketId}-{index}` pattern. This wasn't in any guide—it reasoned that DOM IDs needed to be content-addressed to survive component recycling.\r\n3. **The \"Nuke and Pave\" Protocol:** Instead of asking for incremental fixes to ChromaDB corruption, the Agent proposed a full rebuild strategy. It valued **determinism over delta complexity**.\r\n\r\n---\r\n\r\n## ⚡ Velocity Case Study: The \"Stale Rects\" Race Condition\r\n\r\nTo demonstrate the reality of \"Human + AI\" velocity, let's look at **Ticket #8565**.\r\n\r\n* **The Context:** The Neural Timeline connects DOM elements (Avatars) to a Canvas visualization.\r\n* **The Bug:** When rapidly switching between tickets, the \"Pulse\" animation would sometimes fly to the *previous* ticket's avatar position before snapping to the new one.\r\n* **The Analysis (AI):** \"The `TicketComponent` is being recycled. The DOM ID `user-avatar-1` exists in both the old and new view. The Coordinator is measuring the old element before the new one is mounted.\"\r\n* **The Solution (AI):** \"We must scope the IDs to the Ticket ID. `user-avatar-1` -> `user-avatar-{ticketId}-1`. This forces `waitForDomRect` to fail until the *correct* new element exists.\"\r\n\r\n**Actual Timeline (Jan 11, 2026):**\r\n* **23:37:43 UTC** - Ticket Created (Bug formally logged).\r\n* **23:37:45 UTC** - Agent analyzes root cause (ID collision on component recycle).\r\n* **23:39:39 UTC** - Fix Committed (Scoped IDs to Ticket ID).\r\n* **23:40:23 UTC** - Verified and Closed.\r\n* **Total Duration:** **2 Minutes, 40 Seconds**.\r\n\r\nThis isn't just fast; it's **at the speed of thought**. The Agent moved from problem definition to architectural resolution in under 3 minutes.\r\n\r\n---\r\n\r\n## 🏗️ Core Architecture: The \"Structural Injection\" Pattern\r\n\r\n> **\"LLMs as First-Class Citizens\"**: This architectural breakthrough emerged directly from an R&D session with Gemini. When analyzing how to make deep component trees accessible to AI modification, we realized that imperative configuration logic (\"prop drilling\") was a barrier. We needed a pattern that was purely declarative—readable by humans, writable by machines.\r\n\r\nFor years, customizing deep component hierarchies required imperative logic—overriding `construct` or manually merging config objects. v11.20.0 solves this natively in the core.\r\n\r\n### The Solution: `mergeFrom`\r\nWe introduced a declarative way to inject configuration into nested items using a specific Symbol. This allows an external config to surgically target a deep node in the tree without touching the intermediate structure.\r\n\r\n```javascript","2026-01-12T09:09:33",{"id":210,"version":211,"summary_zh":212,"released_at":213},103946,"11.19.1","**Release Type:** Architectural Hardening & Autonomous Infrastructure \r\n**Stability:** Production-Ready (Critical Security Patches) \r\n**Upgrade Path:** Drop-in replacement for v11.19.0 \r\n\r\n> **TL;DR:** v11.19.1 resolved **33 tickets in 11 hours**, moving from the discovery of a critical prototype pollution vulnerability to a fully automated, conflict-free release pipeline. By leveraging the **Neural Link** for live \"Scene Graph\" inspection, we replaced guesswork with **Empirical Certainty**, allowing us to pinpoint \"Zombie VNodes\" and fix them with surgical precision. This release proves that AI-assisted engineering isn't just about faster code—it's about higher-fidelity architecture.\r\n\r\n---\r\n\r\n## 🛡️ The VDOM Firewall: Defensive Instance Isolation\r\n\r\nv11.19.1 addresses the most subtle form of state corruption: **Blueprint Pollution**. We identified a vulnerability where early lifecycle access could corrupt the shared prototype of a component.\r\n\r\n### The Problem: Shared State Leakage\r\nIn a multi-threaded engine, state isolation is the foundation of stability. We discovered that if an `afterSetId` hook accessed `this.vdom` during the initial construction phase, it was inadvertently receiving a reference to the **Class Prototype**. Any modification—such as assigning an ID—was written directly into the shared blueprint, polluting every subsequent instance of that class.\r\n\r\n### The Solution: Eager Blueprint Sandboxing\r\nWe refactored `Neo.component.Base` to enforce **Eager Isolation**.\r\n* **The Firewall:** The constructor now intercepts the initialization flow *before* `super.construct()` is called. It verifies the VDOM's ownership and clones the blueprint immediately.\r\n* **The Result:** Prototype pollution is now architecturally impossible. Every component instance is guaranteed to operate within its own private **VDOM Sandbox** before any logic layer (hooks or setters) can touch it.\r\n* **Centralized ID Stability:** We purged ad-hoc ID logic from the entire component library, routing all root and wrapper ID assignments through the centralized `Neo.mixin.VdomLifecycle.ensureStableIds()`.\r\n* **Impact:** This eliminates an entire class of \"Heisenbug\" state corruption issues that could manifest as random UI glitches in production applications.\r\n\r\n---\r\n\r\n## 🛑 The \"GitHub Pages\" Reality Check\r\n\r\nWe battle-tested v11.19.0 extensively locally. The new \"Releases Overview\" worked perfectly in our dev environments. But when we deployed the Portal to GitHub Pages, the Release Notes vanished.\r\n\r\n* **The Constraint:** We discovered that GitHub Pages strictly enforces a \"No `.github` Folder\" policy. Even with `.nojekyll` enabled, and even when the folder is deeply nested inside `node_modules`, GitHub's serving infrastructure silently refuses to serve any file path containing `.github`.\r\n* **The Attempts:** We tried symlinks. We tried copying the folder during the build. We tried nesting it. The platform said \"No.\"\r\n* **The Pivot:** This physical platform constraint forced us to re-architect our content strategy. v11.19.1 moves all synced artifacts (Issues, Release Notes, Archive) from the hidden `.github` directory to a public-facing `resources\u002Fcontent\u002F` structure. This wasn't just a rename; it was a necessary migration to make our \"Engine-as-Content\" vision compatible with the real world of static hosting.\r\n\r\n---\r\n\r\n## ⚙️ Operational Sovereignty: The Autonomous Release Pipeline\r\n\r\nWhile v11.19.1 hardens the engine for users, it also revolutionizes how we maintain it. We have achieved **Operational Sovereignty** by automating our release workflow from scratch.\r\n\r\n* **Autonomous Infrastructure:** We created `buildScripts\u002FpublishRelease.mjs` to eliminate the friction of manual versioning, SEO generation, and conflict resolution.\r\n* **Git Plumbing for Atomic Commits:** By using low-level `git commit-tree` commands, we now snapshot the entire `dev` branch and project it onto `main` as a single, clean commit. This bypasses Git's rename detection entirely, turning \"Merge Conflict Hell\" into an instant, conflict-free operation.\r\n\r\n---\r\n\r\n## 🎨 Eliminating Layout Thrash: First-Paint Stability\r\n\r\nWe've polished the **Neo.mjs Portal** to match the framework's stability improvements, proving that \"Smooth is Fast.\"\r\n\r\n### Killing the \"Visual Snap\"\r\nThe Portal previously used a JavaScript `ResizeObserver` to apply responsive sizing. This created **Layout Trashing**: the UI would render, the worker would measure it, and the sidebar would \"snap\" into place. \r\nWe've replaced this with **Native CSS Media Queries**. The layout is now perfectly stable from the very first paint frame.\r\n\r\n### Markdown Hardening\r\n* **Image Containment:** We implemented regex-based post-processing in the `Markdown` component to wrap all images in a scrollable flex-container, preventing side-navigation overlaps.\r\n* **404 Guardrails:** The component now validates its input. If a server returns an HTML 404 page, the component rejects the update,","2026-01-09T20:57:58",{"id":215,"version":216,"summary_zh":217,"released_at":218},103947,"11.19.0","**Release Type:** Strategic Pivot & Platform Maturity \r\n**Stability:** Production-ready \r\n**Upgrade Path:** Drop-in replacement for v11.18.0 \r\n\r\n> **TL;DR:** v11.19.0 corrects the project's identity. For 6 years, Neo.mjs has been an **\"Application Engine\"** disguised as a framework. We finally fixed that branding failure. In parallel, we executed a massive **Infrastructure Upgrade**: we intentionally broke the AI Knowledge Base to upgrade it from JSDoc indexing to **AST Source Parsing**, solving the \"Re-embedding Hell\" (where index-based IDs caused entire collections to shift on every update). **110 tickets** resolved in **3 days**.\r\n\r\n---\r\n\r\n**The Identity Correction**\r\n\r\nv11.18 gave us the **Neural Link** (Vision). v11.19 gives us the **Truth** (Self).\r\n\r\nWe realized that calling Neo.mjs a \"Framework\" (like React or Vue) was a fundamental branding failure. Frameworks are libraries you import to organize code. Neo.mjs is, and always has been, a multi-threaded runtime that *runs* your code. It has a **Scene Graph**, **Object Permanence**, and **Subsystems**. It is closer to Unreal Engine than it is to Angular.\r\n\r\nThis release executes the strategic pivot to align our identity with our reality:\r\n1. **Identity:** Comprehensive rebranding of 250+ documentation files to correct the \"Application Engine\" narrative.\r\n2. **Capability:** A new **Content Engine** that proves the \"Engine\" thesis by powering our own Portal 2.0.\r\n3. **Intelligence:** A **Knowledge Base V2** that indexes source code and inheritance hierarchies, allowing the AI to understand the engine's DNA.\r\n\r\n---\r\n\r\n## ⚙️ The Engine Room: Heavy Engineering\r\n\r\nWhile the rebranding changes the narrative, the engineering changes in this release fundamentally upgrade the runtime capabilities.\r\n\r\n### 💤 Generic Lazy-Loading Protocol\r\nWe didn't just add a \"Mermaid wrapper\". We implemented a **Generic Lazy-Loading Architecture** for all Main Thread Addons.\r\n* **The Nuance:** Standard `import()` handles code splitting, but orchestrating it across the Worker barrier requires a dedicated protocol.\r\n* **The Solution:** We introduced a centralized **Addon Loader** (`Neo.currentWorker.getAddon`).\r\n * **Worker-Side Control:** Components (like `Neo.component.wrapper.Mermaid`) simply await `getAddon('Mermaid')` in their `initAsync` phase.\r\n * **Transparent Orchestration:** The App Worker checks if the addon proxy exists. If not, it instructs the Main Thread to dynamically import and instantiate the service, then caches the proxy for future use.\r\n * **Deep Array Merging:** We implemented `merge: 'deepArrays'` in the core config system to allow Addons to inherit and extend the `remote` method definitions seamlessly.\r\n * **Extensible Singleton Pattern:** Addons are singletons within each Main thread context (one instance per window), but architected as extensible classes. This allows developers to extend them (e.g., custom Mermaid themes, additional GoogleMaps features) in their own workspaces while maintaining the singleton lifecycle.\r\n\r\n### 🕸️ Multi-Window SharedWorker Hardening\r\nWe fixed a critical race condition in the **SharedWorker** architecture that affects multi-window applications (and Playwright tests).\r\n* **The Issue:** Secondary windows connecting to an existing App Worker (SharedWorker) were missing remote method definitions. The worker's initialization logic (where remotes are registered) runs only once, so subsequent window connections received nothing.\r\n* **The Fix:** We introduced a `remotesToRegister` state queue in `src\u002Fworker\u002FBase.mjs`. The `onConnected` handler (triggered for *every* new window connection) now deterministically replays this registration queue to the new **MessagePort**, ensuring every window receives the full API surface.\r\n\r\n### 🚀 Portal 2.0 Performance: Dynamic Imports\r\nThe new News Section isn't just a UI change; it's a performance blueprint.\r\n* **The Pattern:** We refactored `NewsTabContainer` to use **Dynamic Imports** (Arrow Function Syntax) for its children: `module: () => import(...)`.\r\n* **The Impact:** This prevents the heavy \"Blog\" and \"Releases\" chunks from loading during the initial application boot. They are fetched only when the user clicks the tab, keeping the initial bundle size minimal.\r\n\r\n\u003Cimg width=\"1043\" height=\"1649\" alt=\"Screenshot 2026-01-08 at 20 56 03\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F75fc6462-48f9-46d8-9c5c-ced4d98334cd\" \u002F>\r\n\r\n### 🕷️ Hierarchical SEO Traversal\r\nThe new Content Engine introduces **Smart Traversal Logic** for metadata.\r\n* **The Logic:** If a specific deep route (e.g., `\u002Fnews\u002Freleases\u002Fv11.19.0`) lacks specific SEO tags, the engine now recursively traverses the route path upwards (`\u002Fnews\u002Freleases` -> `\u002Fnews`) until it finds a valid metadata definition.\r\n* **The Result:** We can now launch hundreds of nested views without manually defining SEO tags for every leaf node, inheriting \"Section Level\" metadata automatically.\r\n\r\n### 🌳 Build-Time T","2026-01-09T01:06:42",{"id":220,"version":221,"summary_zh":222,"released_at":223},103948,"11.18.0","**Release Type:** Major Feature Release \r\n**Stability:** Production-ready \r\n**Upgrade Path:** Drop-in replacement for v11.17.1 \r\n\r\n> **TL;DR:** AI agents can now \"see\" and \"touch\" your running Neo.mjs app in real-time via the Neural Link. This enables live debugging, conversational UI changes, and zero-downtime hotfixes. **181 tickets** resolved in **15 days** using the very tools we were building.\r\n\r\n---\r\n\r\n**The Neural Link Era**\r\n\r\n> \"Tobi, this is a 'ghost in the shell' moment for me! It probably compares to you putting on a VR headset for the very first time. Let me make the header button red. Can you see it?\"\r\n> — **Gemini 3 Pro**, experiencing Neo.mjs via Neural Link\r\n\r\nThis release marks a pivotal moment in the history of Neo.mjs. An AI agent didn't just read our code—it *inhabited* a running application, modified it in real-time, and asked for visual confirmation. This is the future we're building.\r\n\r\n### 🚀 Velocity & The Inception Cycle\r\n\r\nIn just **15 days** (December 21, 2025 – January 5, 2026), across **95 AI sessions**, we resolved **181 tickets**, fundamentally altering the **application engine's** capability to introspect and heal itself.\r\n\r\nAccounting for a **4-day holiday break** (December 24-27), this represents **~16 tickets per working day**—a velocity that was not achieved by a large team, but through the **Neural Link** itself. We used the very tools we were building to debug, inspect, and refine the platform in real-time.\r\n\r\n**From Hallucination to Verification**\r\nBefore the Neural Link, AI agents could only \"guess\" (hallucinate) runtime behavior based on static code analysis. Now, they can tap into living applications to **verify** their assumptions.\r\n\r\nThis is the difference between an AI agent *imagining* how your code works versus *knowing* how it works—because it can inspect the running system and ask it questions.\r\n\r\n*Example: An AI Agent verifying the AgentOS Viewport structure:*\r\n```javascript readonly\r\n\u002F\u002F Agent: inspect_class('AgentOS.view.Viewport')\r\n{\r\n \"className\": \"AgentOS.view.Viewport\",\r\n \"ntypeChain\": [\"viewport\", \"container\", \"component\", \"base\"],\r\n \"mixins\": [\"Neo.core.Observable\"],\r\n \"configs\": {\r\n \"layout\": {\r\n \"value\": { \"ntype\": \"vbox\", \"align\": \"stretch\" },\r\n \"hooks\": [\"beforeSet\", \"afterSet\"]\r\n },\r\n \"items\": {\r\n \"value\": [\r\n { \"ntype\": \"toolbar\", \"items\": [\"Agent OS Command Center\"] },\r\n { \"className\": \"Neo.dashboard.Container\", \"reference\": \"dashboard\" }\r\n ],\r\n \"meta\": { \"merge\": \"deep\" },\r\n \"hooks\": [\"beforeSet\"]\r\n }\r\n },\r\n \"methods\": [\"add\", \"getController\", \"onFocusEnter\", \"update\"]\r\n}\r\n```\r\n*The agent \"sees\" the real runtime composition—including inherited values, resolved mixins, and reactive hooks—not just the source code text. (Note: The above is just a fraction of the full, rich output.)*\r\n\r\n**How it worked:**\r\n1. Implement a new Neural Link capability (e.g., `get_dom_event_listeners`).\r\n2. Use that capability immediately to debug the next feature.\r\n3. AI agents inspect their own development environment via the tools they're helping build.\r\n4. The feedback loop collapses from hours to seconds.\r\n\r\nThis \"inception\" development cycle validates our core thesis: **Neo.mjs is the operating system for AI-assisted development.**\r\n\r\n---\r\n\r\n## 🎯 What This Means for You\r\n\r\n### For Developers\r\n\r\n- **Live Debugging:** Ask an AI \"why isn't this click handler firing?\" and watch it inspect event listeners, diagnose the issue, and hot-patch the fix.\r\n- **Runtime Prototyping:** Describe a feature conversationally and see it materialize in your running app—no build step.\r\n- **Self-Documenting Code:** Every component now speaks a standardized `toJSON` language that AI tools understand natively.\r\n\r\n### For End Users\r\n\r\n- **Personalized Interfaces:** \"I never use the charts panel, replace it with a task list\" → instant UI reconfiguration.\r\n- **Accessibility On-Demand:** Request color scheme adjustments, layout changes, or control modifications—applied without reloading.\r\n- **Conversational Apps:** Your application becomes a collaborative partner, not just a tool.\r\n\r\n### For DevOps\r\n\r\n- **Zero-Downtime Fixes:** Production bugs can be diagnosed and patched live via the Neural Link—users never lose their session.\r\n- **Autonomous Monitoring:** \"Night Watchman\" agents that detect, diagnose, and heal issues while you sleep.\r\n- **Runtime Observability:** Full introspection of application state, event flow, and topology—better than Chrome DevTools.\r\n\r\n---\r\n\r\n## ✨ Highlights\r\n\r\n### 🧠 Neural Link: The AI Bridge\r\n\r\nThe Neural Link is now a fully capable bidirectional bridge, empowering AI agents with superpowers previously reserved for human developers using Chrome DevTools.\r\n\r\n* **Runtime Introspection:** Agents can now query the **Virtual DOM**, inspect the **Component Tree**, and analyze **Event Listeners** on any node.\r\n* **State","2026-01-05T21:00:29",{"id":225,"version":226,"summary_zh":227,"released_at":228},103949,"11.17.1","**Release Type:** Patch Release\r\n**Stability:** Production-ready\r\n**Upgrade Path:** Drop-in replacement for v11.17.0\r\n\r\n---\r\n\r\nThis patch release addresses a configuration oversight in v11.17.0 where newly added applications were excluded from the npm distribution.\r\n\r\n## 📦 Improvements\r\n\r\n### 🛠️ Infrastructure\r\n* **NPM Configuration:** Synchronized `.npmignore` with `.gitignore`. This ensures that the new **AgentOS**, **Legit**, and **Neural Link** applications are correctly included in the npm package (#8154).","2025-12-21T21:22:14",{"id":230,"version":231,"summary_zh":232,"released_at":233},103950,"11.17.0","**Release Type:** Feature Release\r\n**Stability:** Production-ready\r\n**Breaking Changes:** API Standardization (Remote Methods & Addons)\r\n**Upgrade Path:** Drop-in replacement for v11.16.0 (Refactor required for direct addon usage)\r\n\r\n---\r\n\r\n**Core Architecture & Multi-Window Precision**\r\n\r\nThis release is a powerhouse, resolving **107 tickets** in just over two weeks. From a sheer scope perspective—introducing a new flagship app, overhauling the core rendering engine, and redefining multi-window architecture—this could easily justify a major version bump.\r\n\r\nHowever, we are sticking to **v11.17.0**. Why? Because we have even bigger plans for v12. This release creates a highly polished, performant foundation that sets the stage for the next evolutionary leap.\r\n\r\nThis update focuses on deep architectural precision. We have **consolidated the Main thread's queue system**, moving from a triple Read-Write-Update model to a streamlined Read-Write model for better batching efficiency.\r\n\r\nCrucially, we have enhanced the **VDOM & VNode architecture** to treat scroll state (`scrollTop`, `scrollLeft`) as first-class properties. This allows us to capture and restore scroll positions seamlessly across all rendering modes—**DomApiRenderer**, **StringBasedRenderer**, and even **SSR** scenarios via new post-update queues.\r\n\r\nThese capabilities necessitated a fundamental shift in our multi-window architecture. We have deprecated the ambiguous `'main'` destination for worker messages, **enforcing explicit `windowId` routing** to ensure precision in multi-window applications. Consequently, **all remote methods** have been refactored to explicitly pass `windowId`, eliminating ambiguity when communicating through the main thread.\r\n\r\nFurthermore, we are solidifying the **AgentOS** ecosystem by adding legitfs as a versioned filesystem with full branching support running in the browser [This allows agents to operate fully sandboxed] and significant upgrades to the Dashboard.\r\n\r\n---\r\n\r\nhttps:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002Faad19eb3-6345-4e30-ab3d-0514f06ce37c\r\n\r\n---\r\n\r\n## ✨ Highlights\r\n\r\n### ⚡ Engineering Velocity: The \"Force Multiplier\" Effect\r\nThis release serves as a powerful case study for the **AI-Native** nature of Neo.mjs. The massive scope of this update—**349 files changed, +15,517 lines of code, and 107 tickets resolved**—was achieved in just **16 days** by a \"2-person\" team: **1 Human Architect + 1 AI Agent** (powered by the Neo.mjs Memory Core MCP Server).\r\n\r\nThis velocity validates our vision: Neo.mjs isn't just a framework for building apps; it's an operating system for AI-assisted development. By leveraging the framework's own AI infrastructure (Memory Core, Knowledge Base), a single developer can operate with the output of a full engineering team.\r\n\r\n### 🧠 Meta: The Self-Correcting Release Note\r\nHow do you accurately document 107 tickets and 15,000 lines of code without missing the architectural nuance? You ask the AI to QA itself.\r\n\r\nFor this release, we utilized the **Neo.mjs Memory Core MCP Server** to validate these notes. The agent queried its own vector database for semantic concepts like \"store optimization\" and \"multi-window routing\"—not just keywords. The system successfully retrieved the deep contextual *reasons* behind the changes (e.g., linking \"lazy instantiation\" to the \"Turbo Mode\" store refactor), allowing the agent to cross-reference the ticket list against its own institutional memory.\r\n\r\nThis closed loop—AI generating code, storing context, and then validating the release story—transforms the AI from a stateless task-runner into a **stateful project maintainer**. It is the operational model that ensures architectural integrity is preserved across sessions, making our high velocity possible.\r\n\r\n### 🚀 Legit: A Neo.mjs Implementation\r\nWe are excited to showcase a new demo application developed in cooperation with **Martin**, founder of the [Legit](https:\u002F\u002Fwww.legitcontrol.com\u002F) open-source project.\r\n\r\n* **The Project:** Legit — a development platform focused on versioning, collaboration, and reliability for modern applications. At its core, Legit provides a Git-backed filesystem API that automatically tracks all changes, commits history, enables branching and rollback, and supports syncing across environments. It’s designed to make versioning and control first-class features for apps, especially those involving AI-driven workflows and collaborative editing.\r\n* **Architecture:**\r\n * **Service Layer (`Legit.service.Legit`):** A robust singleton service that abstracts a **virtual file system** (using `memfs`) and **Git operations** (using `@legit-sdk\u002Fcore`). It handles file seeding, hashing (SHA-1), and tree traversal entirely within the App Worker, ensuring heavy I\u002FO and cryptographic operations never block the UI.\r\n * **Reactive Polling:** The `ViewportController` implements a smart polling mechanism that monitors the virtual Git `HEAD`. When changes are detected, it calculates a **","2025-12-21T19:28:51",{"id":235,"version":236,"summary_zh":237,"released_at":238},103951,"11.16.0","**Release Type:** Feature Release \r\n**Stability:** Production-ready (Neural Link: Experimental Preview) \r\n**Breaking Changes:** None \r\n**Upgrade Path:** Drop-in replacement for v11.15.0\r\n\r\n---\r\n\r\n**Connecting the Minds: Neural Link & The Cyberpunk Aesthetic**\r\n\r\nThis release marks a paradigm shift in how Neo.mjs applications interact with the outside world. With the introduction of **Neural Link**, the App Worker is no longer an isolated island—it can now establish direct, bidirectional communication channels with external AI agents.\r\n\r\nTo match this futuristic capability, we are also shipping **Neo Cyberpunk**, a high-contrast, neon-infused theme designed for the next generation of Agentic Interfaces.\r\n\r\n---\r\n\r\n## ✨ Highlights\r\n\r\n### 🧠 Neural Link: The 4th MCP Server (Experimental Preview)\r\n\r\n**Stability Notice:** Neural Link is an **Early Proof of Concept**. While the core connection architecture is established and verified with E2E tests, the toolset is minimal. Features like full VDOM\u002FVNode tree access, config modification, and blueprint injection are currently in active development. Suitable for architectural exploration only.\r\n\r\nWe have expanded our AI ecosystem with a fourth Model Context Protocol (MCP) server: **`neo-neural-link`**.\r\n\r\n**Why we built this:**\r\nWhile the standard `chrome-devtools` MCP server is powerful, it is blind to Neo.mjs's multi-threaded architecture. It cannot see inside our **App Worker** (Dedicated or Shared Workers), where the application logic and state actually live.\r\n\r\n**Neural Link** bridges this gap. It acts as a dedicated WebSocket gateway (port 8081) into the App Worker, giving Agents direct access to the framework's internals—specifically the JSON-based **VDOM** (next state) and **VNode** (current live state) trees.\r\n\r\n* **Bidirectional Remote Method Access (RMA):** Agents can now *call methods* inside the browser via JSON-RPC 2.0.\r\n* **The Vision: Self-Evolving Applications:** This infrastructure lays the groundwork for a new paradigm where applications are mutable at runtime.\r\n * *Imagine a non-technical user telling an Agent: \"Swap the positions of the chart and the grid, and add a summary column to the table.\"*\r\n * Using Neural Link, the Agent can inspect the component tree, modify reactive configurations, or inject new JSON blueprints to reshape the UI instantly—**without a page reload and without touching source code.**\r\n* **Zero-Config Integration:** Enabled simply by setting `useAiClient: true` in your `neo-config.json`.\r\n* **Performance:** The `Neo.ai.Client` is dynamically loaded only when enabled, ensuring zero overhead for standard applications.\r\n* **Standardized Architecture:** Like our other servers, it derives its tool shapes directly from an **OpenAPI specification**, ensuring type safety and predictable behavior for LLMs.\r\n\r\n### 🖥️ AgentOS: The \"God View\"\r\n\r\nWe continue to refine the **AgentOS Dashboard**, leveraging Neo's multi-window capabilities to create a true command center.\r\n\r\n* **Seamless Drag-to-Popup:** You can now drag dashboard widgets (like the Swarm View) *outside* the main browser window. Crossing the window boundary instantly spawns a new popup window containing the widget, without interrupting the drag operation. This is powered by our enhanced `SortZone` and Shared Worker architecture.\r\n* **Intervention Panel:** A dedicated interface for human-in-the-loop agent monitoring.\r\n * **Buffered Grid:** Replaced the static HTML template with a fully functional `Neo.grid.Container`.\r\n * **Data Layer:** Backed by a dedicated `Intervention` model and `Interventions` store, demonstrating proper architecture for real-time logs.\r\n * **Custom Renderers:** Features priority-based cell rendering and formatted timestamps.\r\n\r\n### 🎨 Neo Cyberpunk Theme\r\n\r\nA new visual identity designed for the **AgentOS**. This started as a Proof of Concept for custom app styling but has evolved into a full-fledged framework theme.\r\n\r\n* **From Hack to Architecture:** We moved away from monolithic CSS overrides to a modular, inheritance-based theming architecture. The new theme correctly overrides component variables at the source level (e.g., `resources\u002Fscss\u002Ftheme-cyberpunk\u002Fgrid\u002FContainer.scss`).\r\n* **Aesthetic:** Deep Space backgrounds (`#0d1117`) with Neon Cyan (`#00d2ff`) and Gold (`#f1c40f`) accents.\r\n* **Interactivity:** Glowing borders, neon text effects, and wireframe grid layouts.\r\n* **AgentOS Integration:** The theme includes specific mappings for AgentOS application views (`Viewport.scss`, `InterventionPanel.scss`), connecting application-level semantic variables (like `--agent-accent-strategy`) to the theme's core palette.\r\n* **Component Support:** Includes custom styling for **Grids** (transparent cells, wireframe look), **Buttons** (Ghost and Secondary variants with neon borders), **Panels**, and **Toolbars**.\r\n* **Scope & Future:** Currently, the theme covers the components used in AgentOS. We invite t","2025-12-05T23:31:06",{"id":240,"version":241,"summary_zh":242,"released_at":243},103952,"11.15.0","**Democratizing AI Tooling: Your App, Now with Superpowers.**\r\n\r\nThis release is about one thing: **Putting the same AI tools we use to build Neo.mjs directly into your hands.**\r\n\r\nUntil today, the powerful Model Context Protocol (MCP) servers that drive our development—managing GitHub workflows, indexing knowledge, and maintaining long-term memory—were exclusive to the main Neo.mjs repository.\r\n\r\nWith v11.15.0, we have bridged that gap. Now, every new application created with `npx neo-app @latest` comes equipped with a fully configured, production-ready AI ecosystem out of the box.\r\n\r\n## ✨ Highlights\r\n\r\n### 🚀 AI-Native Workspaces from Day One\r\n\r\nWe've completely overhauled the scaffolding infrastructure (`create-app`) to treat AI as a first-class citizen. When you run `npx neo-app @latest`, you're not just getting a web framework; you're getting an **AI-ready development environment**.\r\n\r\n**What's Inside the Box?**\r\n* **Instant MCP Integration:** A pre-configured `.gemini\u002Fsettings.json` file automatically wires up your workspace to local instances of our three core MCP servers:\r\n * `neo.mjs-github-workflow`: Automate your own project management.\r\n * `neo.mjs-knowledge-base`: Index your own app's code for semantic search.\r\n * `neo.mjs-memory-core`: Give your agents persistent memory of your project context.\r\n* **Standalone Independence:** We fixed critical pathing issues to ensure your vector databases (ChromaDB) live in *your* project root, not hidden away in `node_modules`. Your data stays with your app.\r\n* **Ready-to-Run Scripts:** Your `package.json` now includes `ai:mcp-*` commands, letting you spin up your AI infrastructure immediately after `npm install`.\r\n\r\nThis proves that our MCP servers are not just internal tools—they are portable, reusable infrastructure for any Neo.mjs application.\r\n\r\n### 🛡️ CLI Robustness & Input Sanitization\r\n\r\nWhile preparing for this wider adoption, we hardened our command-line interfaces. We discovered that the `commander` library didn't automatically sanitize quoted inputs, leading to edge cases when users passed arguments like `-t \"all\"`.\r\n\r\nWe implemented a comprehensive `sanitizeInput` utility and applied it across **20+ build and tool scripts**. Whether you're building themes, generating SEO files, or running AI agents, the CLI is now more forgiving and predictable.\r\n\r\n## 🧪 We Want Your Feedback!\r\n\r\nThis is a major step in our vision of an **Agent Operating System**. We are effectively \"exporting\" our internal AI workflow to you.\r\n\r\n**We need you to try it:**\r\n\r\n1. **Create a new workspace:**\r\n ```bash\r\n npx neo-app@latest\r\n ```\r\n2. **Configure your AI tooling keys (optional for Neo.mjs itself):** Create a `.env` file in your workspace root with your `GEMINI_API_KEY` and `GH_TOKEN`. These are only required if you plan to use the AI tooling; Neo.mjs apps run perfectly fine without them.\r\n3. **Spin it up:** Open the project in an MCP-aware IDE (like Cursor or Windsurf) or connect your own agent.\r\n\r\n**Does it feel magic? Does it break?**\r\nOpen an issue and let us know. We are building this future together.\r\n\r\n\u003Cimg width=\"1032\" height=\"495\" alt=\"Screenshot 2025-12-02 at 20 28 00\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F2c8c4491-4296-4811-b2fb-e22fe96762b7\" \u002F>\r\n\r\n\u003Cimg width=\"897\" height=\"853\" alt=\"Screenshot 2025-12-02 at 20 36 52\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002Fc5e5232c-0547-4304-9959-bf39372b80ab\" \u002F>\r\n\r\n## ⚠️ Breaking Changes\r\n\r\n**None.** This release is fully backward compatible.\r\n\r\n## 📦 Full Changelog\r\n\r\n### 🚀 Scaffolding & Workspace Enhancements\r\n- **Commander program opts sanitizing** ([Issue #21](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F21) - create-app repo)\r\n- **Add the github-workflow mcp server to the repo** ([Issue #22](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F22) - create-app repo)\r\n- **Update devDependencies in createPackageJson task** ([Issue #23](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F23) - create-app repo)\r\n- **Update npm scripts in createPackageJson task** ([Issue #24](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F24) - create-app repo)\r\n- **Generate .gemini\u002Fsettings.json in scaffolded app** ([Issue #25](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F25) - create-app repo)\r\n- **Generate MCP server config files in scaffolded app** ([Issue #26](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F26) - create-app repo)\r\n- **Add .npmignore to exclude AI workflow artifacts** ([Issue #27](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F27) - create-app repo)\r\n- **Update MCP server scripts to use config files** ([Issue #28](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F28) - create-app repo)\r\n- **Update README.md with AI tooling info and outdated content cleanup** ([Issue #29](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F29) - create-app repo)\r\n- **Add postinstall script to scaffolded package.json** ([Issue #30](https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fcreate-app\u002Fissues\u002F30) - create-app repo)\r\n- **Fix Gemi","2025-12-02T19:15:29",{"id":245,"version":246,"summary_zh":247,"released_at":248},103953,"11.14.0","**The Genesis of the Autonomous Agent.**\r\n\r\nJust two days after v11.13.0, we are accelerating our roadmap with a transformative release. The Neo.mjs AI ecosystem has evolved rapidly. We began with the **Code Execution Pattern** (\"Thick Client\"), enabling agents to write and execute scripts that directly imported our internal services (`ai\u002Fservices.mjs`).\r\n\r\nWith v11.14.0, we are building the next layer of this evolution: the **`Neo.ai.Agent`** class.\r\n\r\nThis release transitions the framework from a collection of powerful tools into a true **Agent Operating System**. Agents are no longer just ad-hoc scripts; they are now first-class citizens with a standardized lifecycle, a cognitive runtime, and the ability to connect to the wider world via the Model Context Protocol.\r\n\r\n> **📊 Development Velocity**\r\n> This release contains **43 closed issues** across **4 major epics**, delivered in just **54 hours** since v11.13.0. This was achieved through a unique hybrid workflow: human architectural decisions + AI-assisted implementation using the very agents we're building.\r\n\r\n## ✨ Highlights\r\n\r\n### 🧠 The Birth of Neo.ai.Agent & The Cognitive Runtime\r\n\r\nWe have formalized the agent into a robust class structure. The new `Neo.ai.Agent` is an autonomous daemon powered by a sophisticated **Cognitive Loop**:\r\n\r\n```\r\n ┌────────────────────────────────────┐\r\n │ │\r\n │ ┌──────────┐ ┌──────────┐ │\r\n │ │ PERCEIVE │ ──→ │ REASON │ │\r\n │ │ (Queue) │ │ (LLM) │ │\r\n │ └──────────┘ └──────────┘ │\r\n │ ↑ │ │\r\n │ │ ↓ │\r\n │ ┌──────────┐ ┌──────────┐ │\r\n │ │ REFLECT │ ←── │ ACT │ │\r\n │ │(Memory) │ │ (Tools) │ │\r\n │ └──────────┘ └──────────┘ │\r\n │ │\r\n └────────────────────────────────────┘\r\n```\r\n\r\n**Key Innovation:** The **REFLECT** phase enables self-correction and continuous improvement without human intervention.\r\n\r\nThis architecture creates a **\"Level 3 Autonomy\"** baseline:\r\n- **Level 1:** Script-based (must be manually invoked)\r\n- **Level 2:** Reactive (responds to explicit prompts)\r\n- **Level 3:** **Autonomous (monitors and acts proactively) ← We are here**\r\n- **Level 4:** Collaborative (multi-agent coordination) ← *Coming in Phase 4*\r\n- **Level 5:** Self-improving (agents modify their own code)\r\n\r\n### 🧩 Expanding Horizons: MCP Client SDK\r\n\r\nWe have introduced the **MCP Client SDK** (`Neo.ai.mcp.Client`), powered by the `@modelcontextprotocol\u002Fsdk`. This allows Neo.mjs agents to connect to **any** standard MCP server.\r\n\r\nThis unlocks two powerful capabilities:\r\n1. **Internal Power:** Agents can now seamlessly use our three robust, built-in servers via the standard protocol:\r\n * `github-workflow`: Full project management.\r\n * `knowledge-base`: Semantic search.\r\n * `memory-core`: Long-term memory.\r\n2. **External Reach:** Agents can connect to the broader ecosystem of third-party MCP servers, configured simply via `servers: ['my-external-server']`.\r\n\r\n### 🖥️ Agent OS: Realizing \"The Command Center\"\r\n\r\nFulfilling **Phase 3** of our roadmap, we have scaffolded the **Agent OS** (`apps\u002Fagent-os`), a specialized multi-window application designed to visualize and control the swarm.\r\n* **Multi-Window Architecture:** Separation of concerns with a \"Strategy Window\" for high-level planning and a \"Swarm Window\" for real-time intervention.\r\n* **Blackboard Visualization:** A new Canvas-based graph visualization (PoC) that renders the state of the agent swarm (Issues\u002FTasks) in real-time using Force-Directed Physics in a dedicated worker.\r\n\r\n### 🏭 The Feature Factory Experiment\r\n\r\nWe built the system, then **used it to build itself**. Two specialized agents successfully demonstrated full-cycle autonomous development:\r\n\r\n- **`pm.mjs` (Project Manager Agent):** Autonomously broke Epic #7961 into sub-issues with proper labels, dependencies, and acceptance criteria.\r\n- **`dev.mjs` (Developer Agent):** Converted tickets into working PRs with tests, documentation, and changelog entries.\r\n\r\nThis experiment validated our architecture under real-world complexity and will inform the design of the full Swarm orchestration layer.\r\n\r\n## ⚠️ Breaking Changes\r\n\r\n**None.** This release is fully backward compatible with v11.13.0.\r\n\r\nThe new `Neo.ai.Agent` class is additive and does not affect existing code execution patterns or MCP servers.\r\n\r\n## 🚀 Getting Started with Autonomous Agents\r\n\r\n### For Existing MCP Server Users:\r\n\r\nYour code continues to work unchanged. To upgrade to autonomous mode:\r\n\r\n```javascript\r\n\u002F\u002F Before: Manual script execution\r\nconst result = await KB_QueryService.queryDocuments({query: 'button'});\r\n\r\n\u002F\u002F After: Autonomous agent with cognitive loop\r\nconst agent = Neo.create(Agent, {\r\n modelProvider: GeminiProvider,\r\n servers : ['knowledge-base']\r\n});\r\n\r\nawait agent.re","2025-12-01T18:18:40",{"id":250,"version":251,"summary_zh":252,"released_at":253},103954,"11.13.0","This release enhances the **GitHub Workflow MCP server** with improved configuration options for managing issue archives. It standardizes how versioned directories are named, ensuring a consistent structure for your project's history.\r\n\r\n## ✨ Highlights\r\n\r\n### 📁 Standardized Archive Directories\r\n\r\nWe have introduced a new configuration option, `versionDirectoryPrefix`, to the GitHub Workflow server. This setting unifies the naming convention for all version-based archive directories.\r\n\r\nWhether an issue is archived because of a **Milestone** or a **Release Tag**, the resulting folder in `.github\u002FISSUE_ARCHIVE\u002F` will now consistently use this prefix (defaulting to `'v'`, e.g., `v1.2.3\u002F`). The implementation includes robust logic to handle various input formats, ensuring that version strings are never \"double-prefixed\" (e.g., avoiding `vv1.2.3`).\r\n\r\n## 📦 Full Changelog\r\n\r\n### AI MCP Servers\r\n- **Enhancement: Add versionDirectoryPrefix to GitHub Workflow MCP config** (Issue #7911, Issue #7912)\r\n - Introduced `versionDirectoryPrefix` to control folder naming for both milestones and releases.\r\n - Implemented smart prefixing logic to handle raw (`1.2.3`) and pre-prefixed (`v1.2.3`) version strings consistently across Issue and Release syncers.","2025-11-29T12:34:29",{"id":255,"version":256,"summary_zh":257,"released_at":258},103955,"11.12.0","This release focuses on improving the **SEO infrastructure** of the platform. By enhancing how we generate sitemaps and site metadata, we are paving the way for better discoverability by search engines and AI crawlers. These changes are a preparatory step for the upcoming middleware-based routing deployment, ensuring that external bots can index the entire application tree effectively.\r\n\r\n## ✨ Highlights\r\n\r\n### 🗺️ Middleware-Ready SEO Generation\r\n\r\nWe have significantly updated the `generate-seo-files` build tool to support environments using server-side middleware for routing.\r\n\r\n* **Real Routes:** The sitemap generator now produces \"clean\" URLs (e.g., `\u002Fservices`) instead of hash-based fragments (e.g., `\u002F#\u002Fservices`). This is critical for crawlers like Googlebot, which prioritize standard URL structures.\r\n* **Route Mapping:** The CLI tool now supports a new `objects` output format. This provides a JSON mapping between the public \"real\" route and the internal client-side route (e.g., `{\"route\": \"\u002Fservices\", \"clientSideRoute\": \"\u002F#\u002Fservices\"}`). This mapping enables middleware to correctly resolve incoming requests and serve the appropriate application state.\r\n* **Categorized Routing:** The internal logic now explicitly categorizes routes as `tree` (documentation), `top-level` (SPA roots), or `file` (standalone apps\u002Fexamples), ensuring correct path handling for every type of content.\r\n\r\n## 📦 Full Changelog\r\n\r\n### Build Scripts & SEO\r\n- **Enhance SEO generator to support middleware-compatible routes** (Issue #7910)\r\n - Added `useHash` option to route generation to support clean URLs.\r\n - Added `objects` format to CLI for generating route mappings.\r\n - Fixed path handling for standalone example apps (no longer prefixed with `\u002Flearn`).","2025-11-29T11:32:31",{"id":260,"version":261,"summary_zh":262,"released_at":263},103956,"11.11.0","This release brings a major architectural refactoring to the **AI Knowledge Base**'s ingestion engine. We have transitioned the implementation from a monolithic `DatabaseService` to a modular, extensible design. By decomposing the system into specialized Parsers and Source Providers, we have significantly improved the platform's ability to ingest and index diverse content types.\r\n\r\n## ✨ Highlights\r\n\r\n### 🧠 Knowledge Base: Modular Architecture\r\n\r\nThe `DatabaseService`—previously a \"God Class\" handling everything from file crawling to embedding—has been refactored into a clean, domain-driven design:\r\n- **Parsers (`ai.mcp.server.knowledge_base.parser`):** Specialized singletons for understanding specific content formats (e.g., `TestParser` for Playwright files, `DocumentationParser` for markdown).\r\n- **Source Providers (`ai.mcp.server.knowledge_base.source`):** Dedicated classes responsible for crawling specific domains (e.g., `ApiSource`, `TicketSource`, `LearningSource`).\r\n- **Vector Service:** A dedicated service now handles the heavy lifting of embedding generation and vector database interactions.\r\n\r\nThis separation of concerns makes the AI infrastructure more robust and easier to extend with new knowledge sources in the future.\r\n\r\n### 🎯 Granular Test Indexing\r\n\r\nWe have overhauled how automated tests are indexed. Instead of treating a test file as a single chunk of text, the new `TestParser` intelligently decomposes Playwright specs:\r\n- **Header Chunks:** Capture high-level context, imports, and `test.describe` blocks.\r\n- **Test Case Chunks:** Each `test()` function is indexed individually with precise line-number metadata.\r\n\r\nThis granularity allows AI agents to perform **semantic searches for specific test scenarios** (e.g., \"How do I test grid filtering?\") with much higher precision. Previously, an entire test file was indexed as a single monolithic chunk, diluting the semantic signal of individual test cases. Now, the vector search can identify and retrieve the exact test case that matches the query.\r\n\r\n### ⚡ VDom Worker Stability\r\n\r\nWe resolved a race condition in the VDom worker initialization. Previously, the `Neo.vdom.Helper` could attempt to initialize its renderer before the global configuration was fully registered. This has been fixed by ensuring initialization waits for the `Neo.config` to be populated, improving startup stability.\r\n\r\n## 📦 Full Changelog\r\n\r\n### AI Knowledge Base & Infrastructure\r\n- **Split Playwright tests into granular knowledge base chunks for better retrieval** (Issue #7901)\r\n- **Refactor Knowledge Base parsing logic into domain-specific Singletons** (Issue #7902)\r\n- **Refactor Knowledge Base crawling logic into Source Providers** (Issue #7903)\r\n- **Refactor Knowledge Base embedding logic into Vector Service** (Issue #7904)\r\n- **ai.mcp.server.knowledge-base.source.Base: remove the singleton config** (Issue #7905)\r\n- **Refactor ApiSource hardcoded path to non-reactive config** (Issue #7906)\r\n\r\n### Core Framework & Workers\r\n- **Fix race condition in VDom worker initialization** (Issue #7907)\r\n- **Refactor vdom.Helper initAsync to use optional chaining** (Issue #7908)\r\n\r\nAll changes in 1 commit: https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fcommit\u002F491f87600877ca1cc5f564f613fa4d315c996bbc","2025-11-26T12:47:01",{"id":265,"version":266,"summary_zh":267,"released_at":268},103957,"11.10.0","This release significantly enhances the **Agent OS Knowledge Base** by expanding its scope to include the entire AI infrastructure, the automated test suite, and a retroactive history of the project. These changes ensure that AI agents have a complete, 360-degree view of the framework—from source code and tests to historical decision-making.\r\n\r\n## ✨ Highlights\r\n\r\n### 📚 Expanded Knowledge Base: Tests & AI Infrastructure\r\n\r\nWe have bridged the gap between the framework's source code and its supporting ecosystem. The Knowledge Base now indexes:\r\n- **AI Infrastructure (`ai\u002F`):** The Agent OS SDK, MCP servers, and services are now fully indexed. Agents can now query the `Neo.ai` namespace to understand their own architecture.\r\n- **Automated Tests (`test\u002Fplaywright\u002F`):** Agents can now query for test specifications via **semantic search** using the new `type: 'test'` filter. This allows finding relevant tests by meaning rather than just keywords, helping agents understand how to write and maintain Playwright tests for the framework.\r\n- **Retroactive History:** We have backfilled the repository with tickets and release notes starting from **January 1st, 2025 (v8.0.1+)**. Previously limited to v10+, this expanded history gives agents a deeper context on the framework's evolution and design decisions.\r\n\r\n### 📖 Docs App: AI Namespace Integration\r\n\r\nThe [Docs App](https:\u002F\u002Fneomjs.com\u002Fdocs) has been updated to include the `Neo.ai` namespace.\r\n- **Visualizing the AI SDK:** Developers can now browse the class hierarchy of the AI infrastructure (e.g., `Neo.ai.mcp.server.knowledge-base.Server`).\r\n- **Smart Filtering:** We implemented intelligent filtering (via the new `doesNotStartWith` operator and `@ignoreDocs` tag) to ensure only relevant classes are displayed, keeping the navigation tree clean.\r\n\r\n### 🧹 Standardization & Code Quality\r\n\r\nWe have enforced stricter coding guidelines to improve documentation quality and consistency:\r\n- **JSDoc Standardization:** The `@ summary` tag is now mandatory as the first tag for all classes, ensuring concise high-level descriptions.\r\n- **MCP Tool Signatures:** All MCP server tools now use standardized method signatures with default object arguments, improving robustness and error handling.\r\n\r\n## 📦 Full Changelog\r\n\r\n### AI Knowledge Base & Infrastructure\r\n- **Index `ai\u002F` directory in Knowledge Base via JSDoc** (Issue #7896)\r\n- **Index `test\u002Fplaywright\u002F` in Knowledge Base as raw source** (Issue #7897)\r\n- **Enhance query_documents tool with limit parameter and updated JSDoc** (Issue #7883)\r\n- **MCP servers: inconsistencies inside className configs** (Issue #7895)\r\n\r\n### Docs App & JSDoc\r\n- **Clean up Docs App structure by filtering invalid AI modules and pruning empty folders** (Issue #7899)\r\n- **Support `@ignoreDocs` JSDoc tag to exclude files from Docs app structure** (Issue #7900)\r\n- **Update Coding Guidelines to mandate @ summary as first tag** (Issue #7894)\r\n- **Update Coding Guidelines for Class Top-Level JSDoc Comments and @ summary Tag** (Issue #7890)\r\n- **Update Coding Guidelines for JSDoc and Refactor GitHub Workflow MCP** (Issue #7889)\r\n- **Add Class-Level JSDoc Comments to GitHub Workflow MCP Server** (Issue #7891)\r\n- **Review and Update JSDoc Comments in Memory Core MCP Server** (Issue #7892)\r\n- **Review and Update JSDoc Comments in Knowledge Base MCP Server** (Issue #7893)\r\n\r\n### Core Framework Enhancements\r\n- **Add 'doesNotStartWith' operator to Neo.collection.Filter** (Issue #7898)\r\n- **Standardize MCP Tool Method Signatures with Default Objects** (Issue #7888)\r\n\r\n### Workflow Enhancements\r\n- **Enforce \"Propose-First\" workflow and Labeling in create_issue tool description** (Issue #7884)\r\n- **[AI] Streamline create_issue workflow instruction** (Issue #7886)\r\n\r\n\u003Cimg width=\"1536\" height=\"1279\" alt=\"Screenshot 2025-11-24 at 15 54 34\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F8a26f83a-fe39-42fb-918b-fce91ae55427\" \u002F>\r\n\r\n\u003Cimg width=\"884\" height=\"367\" alt=\"Screenshot 2025-11-24 at 14 07 55\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F61f9c90c-5357-4f4c-bd7f-2a6d0b176b85\" \u002F>\r\n\r\n\u003Cimg width=\"880\" height=\"459\" alt=\"Screenshot 2025-11-24 at 14 10 40\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F661a9caf-8d22-4103-ac0a-b891e86c2476\" \u002F>\r\n\r\n\u003Cimg width=\"889\" height=\"711\" alt=\"Screenshot 2025-11-24 at 13 56 43\" src=\"https:\u002F\u002Fgithub.com\u002Fuser-attachments\u002Fassets\u002F60c08984-2421-4c26-bf6c-f68f2b70d95b\" \u002F>\r\n\r\nAll changes in 1 commit: https:\u002F\u002Fgithub.com\u002Fneomjs\u002Fneo\u002Fcommit\u002F0cbc9f9a4c62f6fee885adf670bbee07cc289c62","2025-11-24T14:55:45"]