Add baseUrl config and update docs routing logic

Introduces a baseUrl property to docs.site.json and site-config, enabling custom documentation root paths. Updates Next.js config, routing, and redirect logic to support custom baseUrl, removes Chinese and advanced types docs, and cleans up related meta files.

Author: hotlong

content/docs.site.json

@@ -1,4 +1,5 @@
 {
+  "baseUrl": "/",
   "meta": {
     "title": "ObjectStack Docs",
     "description": "Enterprise-grade low-code platform documentation",

content/docs/index.cn.mdx

@@ -1,111 +1,102 @@
 ---
-title: "Introduction"
-description: Why the world needs a universal enterprise full-stack protocol standard. Shifting from Code-Driven to Protocol-Driven architecture.
+title: Introduction
+description: The Standard Protocol for AI Software Generation.
 ---
 
-# Introduction: The Protocol-Driven Paradigm
+# ObjectStack Protocol
 
-> "Code rots. Protocols endure."
+**The Standard Protocol for AI Software Generation.**
 
-For the past two decades, enterprise software development has been trapped in a Sisyphean cycle:
+ObjectStack is a set of open specifications that define how Enterprise Applications should be structured, stored, and rendered using declarative data (JSON/YAML) instead of imperative code.
 
-We built CRMs with JSP, then rewrote them in Angular five years later, and rewrote them again in React five years after that. Backends shifted from PHP to Node.js, and then to Go. With every iteration of the tech stack, we are **re-implementing the exact same business logic**—the same form validations, the same permission checks, the same approval workflows.
+It transforms the role of a developer from a **Code Writer** (handling boilerplate, wiring, and glue code) to a **System Architect** (defining schemas, rules, and flows).
 
-This **"Code-Driven"** development model carries a massive hidden cost: **Business logic is tightly coupled with technical implementation.** When the framework becomes obsolete, your business assets depreciate with it, eventually turning into technical debt.
 
-**ObjectStack was born to end this cycle.**
 
-## What is ObjectStack?
+## Why a New Standard?
 
-ObjectStack is not just a framework or a library; it is a **Universal Full-Stack Application Protocol Standard**.
+We are entering the era of **AI-Generated Software**.
+Current frameworks (React, NestJS, Spring Boot) are designed for *humans* to write. They are full of implicit context, complex syntax, and fragile dependencies.
 
-It advocates for the complete separation of **"Intent"** from **"Implementation"**. By defining data, interfaces, and processes through standardized JSON protocols, business logic becomes independent of specific programming languages and database technologies.
+ObjectStack is designed for **AI (and Humans)** to write.
+* **Structured:** Business logic is strictly typed metadata, not free-form code.
+* **Deterministic:** A Schema always compiles to the exact same SQL and UI.
+* **Hallucination-Free:** The Protocol constraints prevent invalid logic.
 
-The core architecture of ObjectStack consists of three pillars:
+## The Trinity Architecture
 
-1.  **ObjectQL (The Data Protocol):** A database-agnostic universal data protocol.
-2.  **ObjectUI (The View Protocol):** A declarative universal interface protocol.
-3.  **ObjectOS (The Runtime Protocol):** A business operating system responsible for orchestration and governance.
+ObjectStack is composed of three decoupled protocols that work together to form a complete Application Kernel.
 
+<div class="grid grid-cols-1 md:grid-cols-3 gap-4">
 
+  <div class="card">
+    <h3>1. ObjectQL</h3>
+    <p><strong>The Data Protocol</strong></p>
+    <p>A Database Compiler that translates universal Schema definitions into optimized SQL for PostgreSQL, SQLite, or MySQL.</p>
+    <a href="/specifications/objectql/overview">Explore Data Layer →</a>
+  </div>
 
-## Core Philosophy
+  <div class="card">
+    <h3>2. ObjectUI</h3>
+    <p><strong>The View Protocol</strong></p>
+    <p>A Server-Driven UI standard that renders pixel-perfect, interactive interfaces from JSON, powered by React & Tailwind.</p>
+    <a href="/specifications/objectui/overview">Explore View Layer →</a>
+  </div>
 
-### 1. Protocol-Driven Development
+  <div class="card">
+    <h3>3. ObjectOS</h3>
+    <p><strong>The Runtime Protocol</strong></p>
+    <p>The Business Kernel responsible for Identity, Workflow Orchestration, and Local-First Synchronization.</p>
+    <a href="/specifications/objectos/overview">Explore Runtime →</a>
+  </div>
 
-In traditional development, business logic is hard-coded into functions:
+</div>
 
-```javascript
-// The Old Way: Imperative & Coupled
-function createOrder(data) {
-  if (data.amount > 1000 && !user.isManager) {
-    throw new Error("Need approval");
-  }
-  db.query("INSERT INTO orders ...");
-}
+## The "Protocol-First" Difference
 
-```
+How does developing with ObjectStack compare to the traditional way?
+
+### The Old Way (Code-Driven)
+To add a "Status" field to a Project entity, you typically touch 4-5 files:
+1.  `ALTER TABLE` (SQL Migration)
+2.  `Project.entity.ts` (ORM Definition)
+3.  `CreateProject.dto.ts` (API Validation)
+4.  `ProjectForm.tsx` (Frontend Component)
+5.  `ProjectList.tsx` (Frontend Table)
 
-In ObjectStack, business logic is defined as **Data (Metadata/Protocol)**:
+### The ObjectStack Way (Protocol-Driven)
+You edit **1 file**:
 
 ```yaml
-# The ObjectStack Way: Declarative & Decoupled
-object: order
+# objects/project.object.yml
 fields:
-  amount: { type: currency }
-validation:
-  - rule: "amount > 1000"
-    guard: "!user.isManager"
-    message: "Need approval"
+  status:
+    type: select
+    options: [planning, active, completed]
+    default: planning
+    searchable: true
 
 ```
 
-* **The Difference:** The YAML configuration above relies on no specific language. It can be executed by a Node.js backend, analyzed by a Python script, or even transmitted to the frontend for immediate client-side validation.
-* **The Value:** Your business logic becomes a **portable, analyzable, and evolvable digital asset**, rather than a pile of code destined for obsolescence.
-
-### 2. Local-First & Data Sovereignty
-
-Cloud-Native brings convenience, but it also strips users of data sovereignty. Data silos created by SaaS vendors leave enterprises without physical control over their own data.
-
-ObjectStack embraces a **Local-First** architecture:
-
-* Applications read and write data primarily to a local database (e.g., SQLite, RxDB).
-* Interactions are instantaneous, requiring no network round-trips.
-* **ObjectOS** handles complex data synchronization and conflict resolution (CRDTs/LWW) in the background.
-
-This means: **Even if the network goes down, your enterprise software remains usable. Even if the cloud provider goes bankrupt, your data remains in your hands.**
-
-### 3. Database-Agnostic
-
-Enterprises should not be locked into a specific database vendor.
-
-**ObjectQL** acts as a **Database Compiler**. You write standard ObjectQL Schema and Query ASTs, and the engine compiles them into:
-
-* **PostgreSQL** (For production environments)
-* **SQLite** (For edge devices or local development)
-* **MySQL / Oracle / SQL Server** (For legacy system integration)
-
-This capability allows architects to choose the optimal storage engine for different scenarios without rewriting a single line of business code.
-
-## Why Now?
-
-AI is reshaping software engineering.
-
-As AI-assisted programming (Copilot) becomes ubiquitous, we are discovering that AI generates **Structured Protocols (JSON/YAML)** far more accurately and safely than it generates **Imperative Code (JavaScript/Python)**.
+* **ObjectQL** automatically migrates the database and updates the API.
+* **ObjectUI** automatically renders the Dropdown in the Form and the Badge in the Grid.
+* **ObjectOS** automatically enforces the allowed values validation.
 
-* AI-generated code is prone to hallucinations and bugs.
-* AI-generated JSON configuration, validated against a Schema, is deterministic and verifiable.
+## Key Features
 
-ObjectStack is an **architecture designed for the AI Era**. It provides a standard semantic layer that AI can perfectly understand and manipulate, making "Software Generation via Conversation" a reality.
+* **⚡ Local-First:** Built for the edge. Applications run on a local SQLite database and sync to the cloud in the background. Zero latency, offline-ready.
+* **🔒 Security by Design:** RBAC and Field-Level Security are injected into the database query compiler. You cannot "forget" to check permissions.
+* **🧩 Enterprise Patterns:** Native support for Master-Detail relationships, Currency math, Workflow State Machines, and Audit Logging.
+* **🔌 Database Agnostic:** Switch from SQLite (Dev) to PostgreSQL (Prod) to Oracle (Legacy) without changing a single line of business logic.
 
-## Overview
+## Getting Started
 
-In the following sections, we will explore the details of these protocols:
+Ready to stop writing boilerplate and start architecting?
 
-* Go to **[Architecture Overview](https://www.google.com/search?q=./03-architecture.md)** to see how the components collaborate.
-* Go to **[Core Values](https://www.google.com/search?q=./02-core-values.md)** to learn more about Local-First thinking.
-* Go to **[Enterprise Patterns](https://www.google.com/search?q=./04-enterprise-patterns.md)** to understand how to handle complex ERP scenarios.
+* **[Core Concepts](https://www.google.com/search?q=/concepts/introduction)**: Understand the philosophy behind the protocol.
+* **[Installation](https://www.google.com/search?q=/getting-started/installation)**: Get the ObjectOS Kernel running in 5 minutes.
+* **[Specifications](https://www.google.com/search?q=/specifications/intro)**: Dive deep into the wire protocols.
 
-:::tip Remember
-The goal of ObjectStack is not just to make you write code faster, but to make the code you write **live longer**.
+:::tip Designed for the Future
+ObjectStack is not just a tool for today; it is a foundation for the autonomous software agents of tomorrow.
 :::