dolphin-server-modules 2.11.7 → 2.11.9

package/DOLPHIN_MASTER_GUIDE_NEPALI.md

@@ -58,6 +58,16 @@ Latest Version: v2.11.4 | Updated: 2026-05-27 | License: ISC
 
 १८. API रेफरेन्स
 
+१९. CCTV Camera & RTSP Streaming: भिडियो म्यानेजमेन्ट र P2P सिङ्क (New v2.11.7)
+
+२०. Dolphin Microservices: API Gateway & WebRPC (New v2.11.7)
+
+२१. Universal HTTP Adapters: Express र Fastify सँग इन्टिग्रेसन (New v2.11.7)
+
+२२. Production Deployment (सर्भर लाइभ गर्ने)
+
+२३. निष्कर्ष (Conclusion)
+
 ०. परिचय र दर्शन (Introduction & Philosophy)
 Dolphin किन जन्मियो?
 ब्याकइन्ड डेभलपमेन्टको दुनियाँमा एक्सप्रेस (Express) सबैभन्दा लोकप्रिय छ। तर एक्सप्रेस पूरानो भइसक्यो। यसमा धेरै अनावश्यक वजन (Bloat) छ र यो मोडर्न एउटा (Modern) async/await सँग सधैँ राम्रोसँग काम गर्दैन।
@@ -765,33 +775,171 @@ import { createDolphinServer } from 'dolphin-server-modules/server';
 
 const app = createDolphinServer();
 
-const UserSchema = z.object({
-  name: z.string().min(3),
-  email: z.string().email(),
-  age: z.number().optional()
+const UserSchema = z.१९. CCTV Camera & RTSP Streaming: भिडियो म्यानेजमेन्ट र P2P सिङ्क (New v2.11.7) 📹
+Dolphin v2.11.7 मा थपिएको यो मोड्युलले औद्योगिक स्तरको भिडियो व्यवस्थापन प्रणाली (Video Management System - VMS) र टेलिकम इन्टरकम (Smart Intercom Telephony) को जग बसाल्छ।
+
+१९.१ Camera & RTSP Streaming Architecture
+- **CameraFrameModule**: यसले क्यामराबाट आउने बाइनरी इमेज बफर (`MJPEG`, `H264`, `H265`) हरूलाई बिना कुनै बाह्य सफ्टवेयर सिधै नोड जेएस (Node.js) बफरमै राखेर स्क्यान र पार्स गर्छ र `rt.pubPush` मार्फत लाइभ बाइनरी स्ट्रिम प्रसारण गर्छ।
+- **RtspPullerModule**: आईपी क्यामरा वा NVR को RTSP युआरएलबाट भिडियो फिड तान्न यसमा दुईवटा ब्याकइन्ड छन्:
+  १. **Pure TCP Backend**: कुनै भारी FFmpeg बिना नै नेटिभ TCP सकेट पार्सर मार्फत भिडियो तान्छ, जसले CPU को भार ९५% सम्म घटाउँछ।
+  २. **FFmpeg Backend**: जटिल कोडेकहरू (जस्तै H.264/H.265) को MJPEG ट्रान्सकोडिङका लागि `ffmpeg` प्रोसेस चलाउँछ।
+
+**RTSP क्यामरा जडान गर्ने उदाहरण:**
+```typescript
+import { createCameraModule, createRtspPuller } from 'dolphin-server-modules/realtime';
+
+const camera = createCameraModule(rt);
+const puller = createRtspPuller(camera);
+
+// १. क्यामरा दर्ता गर्ने र RTSP फिड तान्न सुरु गर्ने
+puller.addCamera({
+  cameraId: 'gate-camera-1',
+  url: 'rtsp://admin:password@192.168.1.100:554/stream1',
+  backend: 'tcp', // वा 'ffmpeg'
+  expectedWidth: 1280,
+  expectedHeight: 720
 });
 
-const apiDocs = generateSwagger({
-  title: "DolphinStore API",
-  version: "1.0.0",
-  modules: [{
-    path: "/users",
-    method: "post",
-    schema: UserSchema,
-    summary: "Create new user",
-    tags: ["Users"]
-  }]
+// २. लाइभ बफर बाइनरी स्ट्रिम सुन्ने
+camera.subscribe('gate-camera-1', (frame) => {
+  console.log(`फ्रेम प्राप्त भयो! साइज: ${frame.sizeBytes} bytes | Codec: ${frame.codec}`);
+});
+```
+
+१९.२ Universal WebRTC Intercom & Signaling System
+यस मोड्युलमा अस्पतालको नर्स कलिङ र अपार्टमेन्ट डोरफोन प्रणालीका लागि उपयुक्त **SIP-style Signaling** संयन्त्र जडान गरिएको छ। यसले ब्राउजर र NVR बीच WebRTC P2P (Peer-to-Peer) अडियो/भिडियो जडान गराउँछ:
+```typescript
+import { createSignaling } from 'dolphin-server-modules/signaling';
+
+const telecom = createSignaling(rt);
+
+// १. इन्टरकम कल सुरु गर्ने (INVITE) र ACK ग्यारेन्टी गर्ने
+const ackReceived = await telecom.invite('resident-app-101', 'guard-console', {
+  roomNo: '101',
+  enableVideo: true
+});
+
+if (ackReceived) {
+  console.log("गार्ड कन्सोलसँग सञ्चार सुरु भयो!");
+}
+
+// २. गार्डले कल उठाउँदा (ACCEPT) र क्यामरा फिड P2P सिङ्क गराउँदा
+await telecom.accept('guard-console', 'resident-app-101', sdpOffer);
+```
+
+---
+
+२०. Dolphin Microservices: API Gateway & WebRPC (New v2.11.7) 🚀
+डल्फिनलाई एउटै सर्भरबाट बहु-सर्भर माइक्रोसर्भिस आर्किटेक्चर (Microservices Architecture) मा लान दुईवटा नवीनतम मोड्युल थपिएका छन्।
+
+२०.१ Dolphin API Gateway (केन्द्रीय प्रोक्सी ढोका)
+यसले बाहिरबाट आउने HTTP र WebSocket अनुरोधहरूलाई सही माइक्रोसर्भिस (Auth, Products, Stream Services) मा पाइप (Stream pipe) र टनेल प्रोक्सी गर्छ:
+```typescript
+import { DolphinAPIGateway } from 'dolphin-server-modules/gateway';
+
+const gateway = new DolphinAPIGateway({
+  routes: {
+    '/api/auth/*': 'http://localhost:3001',     // Auth Service
+    '/api/products/*': 'http://localhost:3002', // Product CRUD Service
+    '/realtime': 'ws://localhost:3003'          // Distributed Realtime Service
+  }
 });
 
-app.get('/docs', (ctx) => {
-  const html = serveSwaggerUI(apiDocs, "DolphinStore API");
-  return ctx.html(html);
+gateway.listen(3000, '0.0.0.0', () => {
+  console.log("Dolphin API Gateway successfully running on port 3000! 🎛️");
 });
+```
+
+२०.२ Dolphin WebRPC (द्रुत अन्तर-सेवा सञ्चार)
+जाभास्क्रिप्ट `Proxy` मा आधारित यो मोड्युलले दुई माइक्रोसर्भिस बीच बिना कुनै झन्झट स्थानीय फङ्सन कल गरे जस्तै गरी (Remote Procedure Call) काम गर्छ:
+
+**RPC Server (UserService - Port 4001):**
+```typescript
+import { DolphinRPCServer } from 'dolphin-server-modules/rpc';
+
+class UserService {
+  async getUserInfo(id: string) {
+    return { id, name: "Dr. Ram Prasad", role: "doctor" };
+  }
+}
+
+const rpcServer = new DolphinRPCServer();
+rpcServer.register('User', new UserService());
+rpcServer.listen(4001);
+```
+
+**RPC Client (OrderService calling UserService):**
+```typescript
+import { DolphinRPCClient } from 'dolphin-server-modules/rpc';
+
+const client = new DolphinRPCClient({ url: 'http://localhost:4001' });
+const userService = client.getService<any>('User');
 
-app.get('/docs/json', (ctx) => ctx.json(apiDocs));
-rt.register(deviceId, socket?, metadata?)	डिभाइस रजिस्टर
-१६. DolphinStore: रिएक्टिभ स्टेट म्यानेजमेन्ट र फिल्टरिङ (Reactive State) 🐬
-Dolphin v2.11.4 मा थपिएको `DolphinStore` ले फ्रन्टइन्डमा डेटा म्यानेजमेन्टलाई अर्को स्तरमा पुर्‍याउँछ। यसले ब्याकइन्डको डेटालाई अटोमेटिक सिङ्क मात्र गर्दैन, तर फिल्टरिङ, सर्टिङ र लोड स्टेटहरू पनि म्यानेज गर्छ।
+// स्थानीय फङ्सन कल गरे जस्तै गरी रिमोट सर्भरको फङ्सन ए-सिङ्क कल गर्ने!
+const doctor = await userService.getUserInfo('doc_789');
+console.log(doctor.name); // Output: "Dr. Ram Prasad"
+```
+
+---
+
+२१. Universal HTTP Adapters: Express र Fastify सँग इन्टिग्रेसन (New v2.11.7) 🔌
+डल्फिनका कन्ट्रोलरहरू र CRUD रुटहरूलाई तपाईँले एक्सप्रेस (Express) वा फास्टिफाइ (Fastify) सर्भरमा सिधै प्लग-इन गर्न सक्नुहुन्छ। यसका लागि डल्फिनले `toExpress` र `toFastify` एडेप्टरहरू प्रदान गर्छ जसले फ्रेमवर्कको `ctx` लाई एक्सप्रेस/फास्टिफाइको `req/res` सँग स्वतः रूपान्तरण गर्छ:
+
+```typescript
+import express from 'express';
+import { createCrudController, toExpress } from 'dolphin-server-modules';
+import { db } from './db.js';
+
+const app = express();
+app.use(express.json());
+
+const ctrl = createCrudController(db, 'Products');
+
+// एक्सप्रेस भित्र डल्फिन कन्ट्रोलर रन गर्ने!
+app.get('/api/products', toExpress(ctrl.getAll));
+app.post('/api/products', toExpress(ctrl.create));
+app.put('/api/products/:id', toExpress(ctrl.update));
+
+app.listen(3000, () => console.log("Express integrated with Dolphin Controllers! 🔌"));
+```
+
+---
+
+२२. Production Deployment (सर्भर लाइभ गर्ने)
+तपाईँको Dolphin सर्भर रकेट जस्तै तयार छ। अब यसलाई लाइभ (World Wide Web) मा राख्न PM2 प्रयोग गरिन्छ जसले क्र्यास भएको खण्डमा तुरुन्त (0.1ms) सर्भरलाई अटो-रिस्टार्ट (Auto-Restart) गर्छ।
+
+PM2 इन्स्टल र सुरु गर्न:
+```bash
+# 1. PM2 लाई Global रूपमा राख्ने
+npm install -g pm2
+
+# 2. तपाईंको Code लाई Build गर्ने
+npm run build
+
+# 3. PM2 द्वारा Background मा सर्भर सुरु गर्ने
+pm2 start dist/index.js --name "dolphin-iot-backend"
+
+# 4. सर्भरका Logs (Error/Info) हेर्न
+pm2 logs dolphin-iot-backend
+```
+
+२३. निष्कर्ष (Conclusion)
+बधाई छ! तपाईँले Dolphin Framework को Master Guide पूरा गर्नुभयो। अब तपाईँ:
+
+✅ हाई-पर्फर्मेन्स API सर्भर बनाउन
+✅ अटोमेटेड CRUD र भ्यालिडेसन प्रयोग गर्न
+✅ RealtimeCore v2.0 सँग पूर्ण रियलटाइम एप्लिकेसन बनाउन
+✅ pubPush/subPull सँग हाई-फ्रिक्वेन्सी डेटा ह्यान्डल गर्न
+✅ pubFile/subFile सँग ठूला फाइलहरू रिज्युम सपोर्ट सहित ट्रान्सफर गर्न
+✅ Device Management सँग डिभाइसहरू ट्र्याक गर्न
+✅ WebRTC Intercom, IP Camera & RTSP Parser व्यवस्थापन गर्न
+✅ Express/Fastify एडेप्टर र API Gateway सँग माइक्रोसर्भिस सञ्चालन गर्न
+✅ अटो-जेनेरेटेड Swagger डकुमेन्टेसन बनाउन
+
+सक्नुहुन्छ।
+
+Happy Coding! 🐬🇳🇵
+नेपालबाट विश्वस्तरको सफ्टवेयर बनाऔँ!��, तर फिल्टरिङ, सर्टिङ र लोड स्टेटहरू पनि म्यानेज गर्छ।
 
 १६.१ स्टेट ट्र्याकिङ (State Tracking)
 प्रत्येक कलेक्सनमा अब निम्न स्टेटहरू हुन्छन्:

package/README.md

@@ -1,107 +1,151 @@
-# 🐬 Dolphin Framework (v2.11.4)
-
-![NPM Version](https://img.shields.io/npm/v/dolphin-server-modules?color=blue&style=flat-square)
-![License](https://img.shields.io/npm/l/dolphin-server-modules?style=flat-square)
-![Downloads](https://img.shields.io/npm/dm/dolphin-server-modules?style=flat-square&color=green)
-
-**Dolphin** is a 2026-ready, ultra-lightweight, and 100% modular backend ecosystem built on native Node.js. Now featuring **Advanced Agentic AI (Cursor-Level)**—Dolphin doesn't just run your code; it understands your entire project, tracks symbols, and performs precision edits using semantic search.
-
-> "Native performance. Agentic AI integration. Multi-model support."
-
----
-
-### 📘 Official Master Guide (Nepal)
-Dolphin Framework को विस्तृत र आधिकारिक गाइड उपलब्ध छ। यसमा **Auth, CRUD, Models, र Controllers** को १००% ट्युटोरियल समावेश छ।
-
-👉 **[Dolphin Master Guide (Web Version)](https://raw.githack.com/Phuyalshankar/dolphin-server-modules/main/guide.html)** *(Most Up-to-Date)*
-
----
-
-## 🤖 Cursor-Level AI Features (New in v2.11.4)
-
-Dolphin v2.11.4 introduces a complete overhaul of the AI Agent, bringing it closer to professional AI editors like Cursor.
-
-### 1. Semantic Project Search
-The AI doesn't just look at one file; it indexes your entire project. When you ask a question, it uses semantic token overlap to find the 5 most relevant files automatically.
-
-### 2. Symbol & Reference Tracking
-Dolphin indexes every `function`, `class`, and `variable` across your project. The AI knows exactly where a symbol is defined and where it's used.
-
-### 3. Precision Patching (No Full Re-writes)
-Using the new **Patch Tool**, Dolphin performs surgical edits to your code. No more slow, risky full-file overwrites for small changes.
-
-### 4. Multi-Model Support (Local & Cloud)
-Use any AI provider you want. Supports **Google Gemini**, **Groq (Llama 3)**, and **Local Ollama (Gemma 3/Llama 3)**.
-```bash
-# To use Local Ollama, set this in .env:
-USE_OLLAMA=true
-OLLAMA_MODEL=gemma3:latest
-```
-
-### 5. Personalized Support (Roman Nepali)
-The agent understands and replies in **Roman Nepali** (e.g., "Sanchai hunuhunchha?"), making it more comfortable for Nepali developers.
-
----
-
-## 🛠️ CLI Usage
-
-```bash
-# Start the Autonomous AI Agent (Cursor Mode)
-npx dolphin chat
-
-# Architect a full production project
-npx dolphin generate-full "e-commerce backend"
-
-# Scaffold standard components (No AI needed)
-npx dolphin add auth         # Add Auth System
-npx dolphin add crud Product # Add CRUD for Product
-npx dolphin add adapter mongoose # Setup DB
-
-# Initialize folders
-npx dolphin init-prod
-
-# Start Dev Server
-npx dolphin serve --port=3000
-```
-
----
-
-## 🚀 Quick Start (Modern ESM Only)
-
-Dolphin strictly uses **ES Modules (import/export)**. The use of `require()` is discouraged as it causes compatibility issues in modern Node.js environments.
-
-```javascript
-import { createDolphinServer } from 'dolphin-server-modules/server';
-
-const app = createDolphinServer();
-
-app.get('/ping', (ctx) => {
-  return { message: 'pong', status: 'swimming' };
-});
-
-app.listen(3000, () => console.log("🐬 Dolphin v2.11.4 swimming on 3000"));
-```
-
----
-
-## 📊 2026 Performance Benchmarks
-
-| Framework | RPS (Req/sec) | Cold Start | Realtime Throughput |
-| :--- | :--- | :--- | :--- |
-| Express.js | ~15,000 | 180ms | N/A |
-| **Dolphin V2.11** | **45,000+** | **< 10ms** | **35,000+ msgs/sec** |
-
----
-
-## 🗺️ Roadmap
-- [x] **Agentic AI Scaffolding**: Full project generation via Gemini/Groq
-- [x] **Semantic Search & Symbol Indexing**: Precision context building
-- [x] **Multi-Model Support**: Gemini, Groq, and Local Ollama
-- [x] **Precision Patching**: AST-style surgical code edits
-- [ ] **One-Click Deployment**: Deploy to Vercel/Cloudflare from CLI
-- [ ] **Visual Debugger**: Built-in web dashboard for monitoring
-
----
-
-## 📄 License
+# 🐬 Dolphin Framework (v2.11.7)
+
+![NPM Version](https://img.shields.io/npm/v/dolphin-server-modules?color=blue&style=flat-square)
+![License](https://img.shields.io/npm/l/dolphin-server-modules?style=flat-square)
+![Downloads](https://img.shields.io/npm/dm/dolphin-server-modules?style=flat-square&color=green)
+
+**Dolphin** is a 2026-ready, ultra-lightweight, and 100% modular backend ecosystem built on native Node.js. Now featuring **Advanced Agentic AI (Cursor-Level)**—Dolphin doesn't just run your code; it understands your entire project, tracks symbols, and performs precision edits using semantic search.
+
+> "Native performance. Agentic AI integration. Multi-model support."
+
+---
+
+### 📘 Official Master Guide (Nepal)
+Dolphin Framework को विस्तृत र आधिकारिक गाइड उपलब्ध छ। यसमा **Auth, CRUD, Models, र Controllers** को १००% ट्युटोरियल समावेश छ।
+
+👉 **[Dolphin Master Guide (Web Version)](https://raw.githack.com/Phuyalshankar/dolphin-server-modules/main/guide.html)** *(Most Up-to-Date)*
+
+---
+
+## 🤖 Cursor-Level AI Features (New in v2.11.4)
+
+Dolphin v2.11.4 introduces a complete overhaul of the AI Agent, bringing it closer to professional AI editors like Cursor.
+
+### 1. Semantic Project Search
+The AI doesn't just look at one file; it indexes your entire project. When you ask a question, it uses semantic token overlap to find the 5 most relevant files automatically.
+
+### 2. Symbol & Reference Tracking
+Dolphin indexes every `function`, `class`, and `variable` across your project. The AI knows exactly where a symbol is defined and where it's used.
+
+### 3. Precision Patching (No Full Re-writes)
+Using the new **Patch Tool**, Dolphin performs surgical edits to your code. No more slow, risky full-file overwrites for small changes.
+
+### 4. Multi-Model Support (Local & Cloud)
+Use any AI provider you want. Supports **Google Gemini**, **Groq (Llama 3)**, and **Local Ollama (Gemma 3/Llama 3)**.
+```bash
+# To use Local Ollama, set this in .env:
+USE_OLLAMA=true
+OLLAMA_MODEL=gemma3:latest
+```
+
+### 5. Personalized Support (Roman Nepali)
+The agent understands and replies in **Roman Nepali** (e.g., "Sanchai hunuhunchha?"), making it more comfortable for Nepali developers.
+
+---
+
+## 🛠️ CLI Usage
+
+```bash
+# Start the Autonomous AI Agent (Cursor Mode)
+npx dolphin chat
+
+# Architect a full production project
+npx dolphin generate-full "e-commerce backend"
+
+# Scaffold standard components (No AI needed)
+npx dolphin add auth         # Add Auth System
+npx dolphin add crud Product # Add CRUD for Product
+npx dolphin add adapter mongoose # Setup DB
+
+# Initialize folders
+npx dolphin init-prod
+
+# Start Dev Server
+npx dolphin serve --port=3000
+```
+
+---
+
+## 🚀 Microservices & Smart Intercom Ecosystem (New in v2.11.7)
+
+Dolphin v2.11.7 introduces a complete suite of enterprise-grade microservice modules and smart building signaling/streaming pipelines:
+
+### 1. Universal HTTP Framework Adapters
+Run Dolphin's Mongoose-synced CRUD controllers and Auth middleware directly inside **Express** or **Fastify**!
+```javascript
+import express from 'express';
+import { createCrudController, toExpress } from 'dolphin-server-modules';
+
+const app = express();
+const ctrl = createCrudController(db, 'Products');
+
+app.get('/api/products', toExpress(ctrl.getAll));
+```
+
+### 2. High-Performance WebRPC
+Decouple service interactions with a type-safe, Proxy-based, sub-millisecond remote procedure call (RPC) client/server engine:
+```javascript
+import { DolphinRPCClient } from 'dolphin-server-modules/rpc';
+
+const client = new DolphinRPCClient({ url: 'http://localhost:4001' });
+const userService = client.getService('User');
+
+// Call remote methods asynchronously as if they were local!
+const user = await userService.getUserInfo('user_123');
+```
+
+### 3. API Gateway Router
+A zero-dependency reverse proxy server that redirects HTTP and WebSocket upgrade streams dynamically:
+```javascript
+import { DolphinAPIGateway } from 'dolphin-server-modules/gateway';
+
+const gateway = new DolphinAPIGateway({
+  routes: {
+    '/api/auth/*': 'http://localhost:3001',
+    '/api/products/*': 'http://localhost:3002',
+    '/realtime': 'ws://localhost:3003'
+  }
+});
+gateway.listen(3000);
+```
+
+### 4. CCTV Camera, RTSP Puller & WebRTC Intercom
+- **RtspPullerModule**: Feeds streams from IP cameras/NVRs. Features a **Pure TCP RTP buffer parser** (zero external binaries/FFmpeg!) for low-resource environments, and FFmpeg Fallbacks.
+- **UniversalSignaling**: A telecom-ready WebRTC signaling server with native invite-accept-reject-end handshakes and bidirectional ACK confirmations—perfect for smart doorphones and nurse calling systems!
+
+### 5. 100% Hookless Realtime Architecture (New)
+Dolphin introduces `autoBroadcast` and `DolphinStore` allowing you to manage full CRUD data flows in React without writing a single `useState`, `useEffect`, or `onSubmit` handler.
+```javascript
+// 1. Initialize with autoBroadcast
+const dolphin = new DolphinClient('http://localhost:3000', 'dev', { autoBroadcast: true });
+
+// 2. Hookless Form (Automatically syncs to Database and publishes via WebSocket)
+<form data-api-submit="POST /api/products">
+  <input name="productName" />
+  <button type="submit">Save</button>
+</form>
+
+// 3. Auto-updating UI
+const store = useSyncExternalStore(
+  (listener) => dolphin.store.subscribe(listener),
+  () => dolphin.store.getSnapshot('products')
+);
+// 'store.items' updates in realtime automatically when ANY user submits!
+```
+
+---
+
+## 🗺️ Roadmap
+- [x] **Agentic AI Scaffolding**: Full project generation via Gemini/Groq
+- [x] **Semantic Search & Symbol Indexing**: Precision context building
+- [x] **Precision Patching**: AST-style surgical code edits
+- [x] **Express/Fastify Adapters**: Pluggable Dolphin Context middleware
+- [x] **Independent WebRPC & API Gateway**: High-speed microservices orchestration
+- [x] **IP Camera RTSP & WebRTC Intercom**: Pure TCP stream parsing and VoIP SIP signaling
+- [ ] **One-Click Deployment**: Deploy to Vercel/Cloudflare from CLI
+- [ ] **Visual Debugger**: Built-in web dashboard for monitoring
+
+---
+
+## 📄 License
 ISC © 2026 Shankar Phuyal & Dolphin Team.

package/TUTORIAL_NEPALI.md

@@ -98,7 +98,43 @@ OLLAMA_MODEL=gemma3:latest
 
 ---
 
-## ७. अन्तिममा (Conclusion)
+## ७. Hookless Data Management (autoBroadcast) [NEW]
+
+Dolphin मा अब `autoBroadcast` सुविधा थपिएको छ। यसको मद्दतले तपाईँले React मा `useState`, `useEffect`, वा `onSubmit` लेख्नै पर्दैन।
+
+```jsx
+import { useSyncExternalStore } from 'react';
+import { DolphinClient } from 'dolphin-server-modules/client';
+
+// १. autoBroadcast अन गर्नुहोस्
+const dolphin = new DolphinClient('http://localhost:3000', 'dev', { autoBroadcast: true });
+
+function ProductApp() {
+  // २. डेटा आफैँ सिंक (Sync) हुन्छ
+  const products = useSyncExternalStore(
+    (listener) => dolphin.store.subscribe(listener),
+    () => dolphin.store.getSnapshot('products')
+  );
+
+  return (
+    <div>
+      {/* ३. Hookless फर्म: यसले आफैँ API कल गर्छ र सबै प्रयोगकर्तालाई Realtime मा अपडेट पठाउँछ */}
+      <form data-api-submit="POST /api/products">
+        <input name="name" placeholder="प्रोडक्टको नाम" required />
+        <button type="submit">थप्नुहोस्</button>
+      </form>
+
+      <ul>
+        {products.items.map(p => <li key={p.id}>{p.name}</li>)}
+      </ul>
+    </div>
+  );
+}
+```
+
+---
+
+## ८. अन्तिममा (Conclusion)
 
 Dolphin Framework अब एउटा सामान्य फ्रेमवर्क मात्र होइन, यो तपाईँको एउटा "एआई साथी" पनि हो। यसले तपाईँको कोडिङ स्पिड १० गुणा बढाउन मद्दत गर्छ।
 

package/dist/client.test.js

@@ -167,6 +167,17 @@ describe('APIHandler — proxy paths', () => {
         const [, opts] = global.fetch.mock.calls[0];
         expect(opts.headers['Authorization']).toBe('Bearer tok99');
     });
+    test('autoBroadcast — POST request पछि realtime publish गर्छ', async () => {
+        const cAuto = new DolphinClient('http://localhost:3000', 'dev', { autoBroadcast: true });
+        cAuto.publish = jest.fn();
+        global.fetch = makeFetch(200, { data: 'success' });
+        await cAuto.api.request('POST', '/api/users', { name: 'Ram' });
+        expect(cAuto.publish).toHaveBeenCalledWith('api/users', {
+            method: 'POST',
+            payload: { name: 'Ram' },
+            result: { data: 'success' }
+        });
+    });
 });
 // ─────────────────────────────────────────────────────────────────────────────
 // 4. APIHandler — request timeout