docs: stale code-block sweep + slim binding stubs + 0.1.2 install commands

Code-block sweep across the site to align with the actual public API
that shipped in aster-rpc 0.1.2 / @aster-rpc/aster 0.1.2:

- All `from aster.decorators import ...` -> `from aster import ...`
- All `from aster.codec import wire_type` -> `from aster import wire_type`
- All `from aster.types import SerializationMode` -> `from aster import SerializationMode`
  (the `aster.types` module never existed -- previous docs would
  ModuleNotFoundError on copy-paste)
- `scoped="stream"` -> `scoped="session"` (stream is a back-compat alias,
  session is canonical and matches the framework's logging/error output)
- `AsterClient(endpoint_addr=...)` -> `AsterClient(address="aster1...")`
  (endpoint_addr is a back-compat alias; address is canonical and
  matches the Mission Control guide)
- `pip install aster-python` -> `pip install aster-rpc` / `aster-cli`
  (aster-python was never published; the actual PyPI distributions are
  aster-rpc and aster-cli, both at 0.1.2)

Quickstart (python.mdx):
- TypeScript section no longer uses @wiretype for the Hello example.
  TS auto-derives wire tags the same way Python does, so the simplest
  service is genuinely two decorators (@service + @rpc), not three.
  Merged types.ts into service.ts to match the Python "one file" feel.
- Consumer uses the dynamic proxy (`client.proxy("HelloService")`)
  which speaks JSON and needs no local type definitions, matching the
  Mission Control guide style.

Define-a-service guide:
- Removed stray trailing ``` that opened an empty code block in the
  bidi streaming section (markdown rendering glitch).
- Session-scoped service example now uses scoped="session" and
  documents the framework's `cls(peer)` constructor contract.
- Serialization modes table updated: NATIVE now reads "deployments
  where interoperability is second to performance" (clearer than
  the old "single-language deployments where performance matters").
- Added "Proxy method shapes" callout showing all four RPC pattern
  call forms in one place (unary/server-stream/client-stream/bidi),
  to head off the recurring "I tried `await mc.tailLogs(...)` and
  it crashed" QA finding.

Concepts (serialization.mdx):
- Restructured around the actual modes Aster ships: XLANG, NATIVE,
  ROW, JSON. JSON is now described as the debuggability escape hatch
  (the gRPC pain point Aster addresses).
- The dynamic proxy speaks JSON automatically, so any service that
  supports JSON mode can be called from the shell without codegen.

Bindings/python:
- Drop create_local_client and create_session from the API surface
  table -- those are internal helpers, not part of the public API.
- Sessions section now documents the actual two-sided story:
  `@service(scoped="session")` on the producer + `await client.session("Name")`
  on the consumer, which returns a SessionProxyClient that multiplexes
  method calls over a single bidi stream.

Reference/cli.mdx:
- Install instructions point at aster-cli on PyPI (was aster-python).

Slim:
- Delete the empty placeholder index pages for bindings/{dotnet,go,jvm,rust}.
  Those bindings are in progress in the framework repo but the public
  docs site is Python+TypeScript only at 0.1.2; the orphaned stubs
  were misleading. Will be re-added when each binding ships.
- Sidebars updated to drop the deleted entries.
- Homepage (src/pages/index.tsx + custom.css) slimmed to match the
  smaller binding scope.

Mission Control guide left intact: it is the canonical user-facing
walkthrough and was already polished.

Author: emrul

docs/bindings/dotnet/index.mdx

@@ -17,10 +17,11 @@ Production-ready for 0.1-alpha. The Python binding is the first-class implementa
 ## Installation
 
 ```bash
-pip install aster-python
+pip install aster-rpc           # framework
+pip install aster-cli           # optional: shell, contract gen, trust commands
 ```
 
-**Requirements:** Python 3.9+, macOS / Linux / Windows.
+**Requirements:** Python 3.9 -- 3.13, macOS / Linux / Windows.
 
 The package includes a native extension (compiled Rust via PyO3), so wheels are provided for common platforms. Building from source requires a Rust toolchain and maturin.
 
@@ -29,8 +30,7 @@ The package includes a native extension (compiled Rust via PyO3), so wheels are
 ```python
 import asyncio
 from dataclasses import dataclass
-from aster import AsterServer, AsterClient
-from aster.decorators import service, rpc
+from aster import AsterServer, AsterClient, service, rpc
 
 @dataclass
 class HelloRequest:
@@ -52,7 +52,7 @@ async def main():
         addr = srv.address
 
         # Consumer
-        async with AsterClient(endpoint_addr=addr) as client:
+        async with AsterClient(address=addr) as client:
             hello = await client.client(HelloService)
             resp = await hello.say_hello(HelloRequest(name="World"))
             print(resp.message)  # "Hello, World!"
@@ -86,10 +86,8 @@ Define services and methods with decorators on plain Python classes:
 
 | API | Purpose |
 |-----|---------|
-| `AsterClient(endpoint_addr=...)` | High-level declarative consumer. Handles admission and service discovery. |
+| `AsterClient(address="aster1...")` | High-level declarative consumer. Handles admission and service discovery. |
 | `create_client(ServiceClass, connection=conn)` | Lower-level client. Wraps an existing QUIC connection. |
-| `create_local_client(ServiceClass, server)` | In-process client using `LocalTransport` (for testing). |
-| `create_session(ServiceClass, connection=conn)` | Session-scoped client with per-connection state. |
 
 ### Configuration
 
@@ -126,8 +124,8 @@ Built-in middleware chain:
 
 | API | Purpose |
 |-----|---------|
-| `@service(scoped="stream")` | Per-connection service instances. |
-| `create_session(ServiceClass, connection=conn)` | Open a session-scoped stream from the client. |
+| `@service(scoped="session")` | Producer-side: per-connection service instances (the class `__init__` receives a `peer` argument). |
+| `await client.session("ServiceName")` | Consumer-side: open a multiplexed session against a session-scoped service. Returns a `SessionProxyClient` whose method calls share one bidi stream. |
 
 ## Architecture
 

docs/bindings/go/index.mdx

@@ -8,9 +8,9 @@ import LanguageTabs, {TabItem} from '@site/src/components/LanguageTabs';
 
 Aster uses [Apache Fory](https://fury.apache.org) for serialization. Fory is a high-performance, cross-language serialization framework that operates on native language objects -- no IDL compilation required, no generated code to maintain.
 
-## Three serialization modes
+## Four serialization modes
 
-Fory provides three distinct serialization modes. Each serves a different use case, and Aster exposes all three. The mode is declared per-service, with per-method override available.
+Aster exposes four serialization modes -- three from Fory and one universal JSON escape hatch. The mode is declared per-service, with per-method override available.
 
 ### XLANG (cross-language)
 
@@ -29,33 +29,30 @@ NATIVE mode uses the language's own serialization primitives -- Fory replaces pi
 
 Use NATIVE when:
 - Both sides of the call are in the same language.
-- Maximum serialization performance is the priority.
-- Cross-language interoperability is not needed for this service.
+- Deployments where interoperability is second to performance.
 
 ### ROW (zero-copy random access)
 
-ROW mode produces a columnar binary format that supports zero-copy field access. Individual fields can be read without deserializing the entire message. This is useful for data-heavy workloads where only a subset of fields is needed per operation, or where integration with columnar data systems (e.g., Apache Arrow) is valuable.
+ROW mode produces a row-oriented binary format from Fory that supports zero-copy field access. Individual fields can be read without deserializing the entire message. Useful for data-heavy workloads where the consumer reads only a subset of fields per record, or where the schema is sent once and many rows follow.
 
 Use ROW when:
 - Payloads are large and consumers often access only a few fields.
-- Partial deserialization improves performance.
-- Columnar data integration is needed.
+- You're streaming many records with a stable schema (the schema is hoisted into the first frame and amortized across the stream).
+- You're integrating with columnar data systems.
 
-### JSON (universal fallback)
+### JSON (debuggable, universal)
 
 JSON mode uses UTF-8 JSON for request and response payloads. All frames on a stream -- including the `StreamHeader` and `RpcStatus` trailer -- are JSON objects. Field names use camelCase.
 
-JSON mode exists for language bindings where the Fory XLANG implementation is not yet production-ready (e.g., TypeScript). All Aster servers accept JSON mode alongside their declared Fory modes -- no configuration needed.
-
 Use JSON when:
-- The client is in a language without a mature Fory XLANG implementation.
-- Debugging wire traffic (JSON is human-readable).
-- Building quick prototypes with the proxy client.
+- You want readable wire traffic for debugging (`tcpdump` / `wireshark` show payloads as plain text instead of opaque binary -- the classic gRPC pain point).
+- You're building quick prototypes with the dynamic proxy client (`client.proxy("ServiceName")`), which always speaks JSON.
+- A client is in a language without a mature Fory XLANG implementation.
 
-Clients that support Fory XLANG should prefer it for performance. JSON mode is a universal fallback, not the primary path.
+Clients that support Fory XLANG should prefer it for performance and payload size. JSON mode is the escape hatch, not the primary path.
 
 :::info
-The Python proxy client (`client.proxy("ServiceName")`) uses JSON mode automatically. Generated typed clients use Fory XLANG.
+The dynamic proxy client (`client.proxy("ServiceName")`) uses JSON mode automatically -- so any service that supports JSON mode can be called from the shell or from a Python/TypeScript proxy without generating a typed client first. Generated typed clients use Fory XLANG by default.
 :::
 
 ## Mode selection
@@ -66,7 +63,7 @@ A service declares its default serialization mode. Individual methods can overri
   <TabItem value="python" label="Python">
 
 ```python
-from aster import service, rpc, server_stream, SerializationMode
+from aster import service, rpc, SerializationMode
 
 @service(
     name="Analytics",