vibes-plug 2.5.0 → 2.11.0

package/skills/desktop-electron-expert/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: desktop-electron-expert
+description: "Expert guide for Electron 33+ desktop application development — Electron Forge, context isolation, IPC security, native menus, auto-updates, and multi-window management / Panduan ahli pengembangan desktop Electron 33+."
+author: "Roedy Rustam"
+---
+
+# Desktop Electron Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+- **`tauri-expert`**: Comparing Electron vs. Tauri architectures for desktop targets.
+- **`senior-frontend`**: React/Vue frontend architecture inside Electron renderers.
+- **`ci-cd-devops-architect`**: Multi-platform desktop packaging (Windows MSI/EXE, macOS DMG, Linux AppImage).
+- **`error-resilience-expert`**: Crash reporting and main/renderer crash recovery.
+
+### Description
+Production guide for engineering secure, high-performance cross-platform desktop applications using Electron 33+. Covers secure IPC communication via `contextBridge`, mandatory Context Isolation and Sandbox modes, native system integrations (tray, notifications, menus, global shortcuts), auto-updates with `electron-updater`, and build automation with Electron Forge / electron-builder.
+
+### Trigger Conditions
+- Building desktop apps with web technologies using Electron.
+- Hardening Electron security (Context Isolation, Preload scripts, CSP, nodeIntegration: false).
+- Implementing typed IPC communication between Main and Renderer processes.
+- Setting up auto-update workflows and multi-OS code signing.
+
+---
+
+### Core Security & Architecture Patterns
+
+#### 1. Secure Main Process (`main.ts`)
+```typescript
+import { app, BrowserWindow, ipcMain } from 'electron';
+import path from 'path';
+
+let mainWindow: BrowserWindow | null = null;
+
+function createWindow() {
+  mainWindow = new BrowserWindow({
+    width: 1200,
+    height: 800,
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js'),
+      contextIsolation: true,       // MANDATORY for security
+      nodeIntegration: false,        // NEVER enable in renderer
+      sandbox: true,                 // Enable OS-level sandbox
+      webSecurity: true,
+    },
+  });
+
+  if (process.env.NODE_ENV === 'development') {
+    mainWindow.loadURL('http://localhost:5173');
+  } else {
+    mainWindow.loadFile(path.join(__dirname, '../dist/index.html'));
+  }
+}
+
+app.whenReady().then(() => {
+  createWindow();
+
+  // Typed IPC Handlers
+  ipcMain.handle('app:get-version', () => app.getVersion());
+  ipcMain.handle('file:read-config', async (_event, configName: string) => {
+    // Validate arguments safely
+    return { name: configName, loaded: true };
+  });
+});
+```
+
+#### 2. Type-Safe Preload Script (`preload.ts`)
+```typescript
+import { contextBridge, ipcRenderer } from 'electron';
+
+export interface ElectronAPI {
+  getVersion: () => Promise<string>;
+  readConfig: (name: string) => Promise<any>;
+}
+
+const api: ElectronAPI = {
+  getVersion: () => ipcRenderer.invoke('app:get-version'),
+  readConfig: (name: string) => ipcRenderer.invoke('file:read-config', name),
+};
+
+contextBridge.exposeInMainWorld('electronAPI', api);
+```
+
+#### 3. Renderer Consumer (`renderer.tsx`)
+```tsx
+declare global {
+  interface Window {
+    electronAPI: ElectronAPI;
+  }
+}
+
+import React, { useEffect, useState } from 'react';
+
+export function AppInfo() {
+  const [version, setVersion] = useState<string>('');
+
+  useEffect(() => {
+    window.electronAPI.getVersion().then(setVersion);
+  }, []);
+
+  return <div>App Version: {version}</div>;
+}
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Integrasi Orkestrasi
+- **`tauri-expert`**: Pemilihan dan perbandingan antara Electron dan Tauri untuk aplikasi desktop.
+- **`senior-frontend`**: Integrasi framework frontend (React/Vue) di dalam renderer Electron.
+- **`ci-cd-devops-architect`**: Otomasi build installer cross-platform (.exe, .dmg, .AppImage).
+
+### Deskripsi
+Panduan produksi untuk membangun aplikasi desktop cross-platform yang aman dan efisien menggunakan Electron 33+. Mengutamakan keamanan IPC dengan Context Isolation, isolasi proses renderer, integrasi sistem natif (system tray, menu, notifikasi), dan alur auto-update otomatis.
+
+### Kondisi Pemicu
+- Membangun aplikasi desktop menggunakan teknologi web berbasis Electron.
+- Memperketat keamanan Electron (Context Isolation, Sandbox, sanitasi IPC).
+- Mengonfigurasi auto-updater dan packaging multi-OS.

package/skills/documentation-site-expert/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: documentation-site-expert
+description: "Expert guide for technical documentation sites (Mintlify, Docusaurus, Storybook, VitePress) and component documentation / Panduan ahli situs dokumentasi teknis (Mintlify, Docusaurus, Storybook, VitePress) dan dokumentasi komponen."
+author: "Roedy Rustam"
+---
+
+# Documentation Site Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+- **`openapi-swagger-codegen-expert`**: Auto-generated API documentation.
+- **`design-system-architect`**: Component documentation with Storybook.
+- **`astro-framework-expert`**: Astro Starlight for docs sites.
+- **`seo`**: Documentation site SEO and discoverability.
+
+### Description
+Expert guide for building technical documentation sites and component libraries. Covers Mintlify (AI-native docs), Docusaurus 3 (React-powered), Storybook 8 (component playground), VitePress (Vue-powered), Astro Starlight (Astro-powered), and MDX authoring. Includes API reference generation, versioning, search integration, and interactive code playgrounds.
+
+### Trigger Conditions
+- Creating documentation sites for APIs, libraries, or products.
+- Setting up Storybook for component documentation.
+- Choosing a documentation framework.
+- Generating API reference docs from OpenAPI specs.
+
+---
+
+### Framework Selection
+
+| Framework | Stack | Search | Versioning | Best For |
+|-----------|-------|--------|------------|----------|
+| Mintlify | React/MDX | ✅ Built-in AI | ✅ | SaaS API docs |
+| Docusaurus 3 | React/MDX | ✅ Algolia | ✅ | OSS project docs |
+| Storybook 8 | Any framework | ❌ | ❌ | Component docs/playground |
+| VitePress | Vue/Markdown | ✅ Built-in | ❌ | Vue ecosystem docs |
+| Starlight | Astro/MDX | ✅ Pagefind | ✅ | Content-heavy docs |
+
+**Recommendation:** Use **Mintlify** for SaaS API docs. Use **Docusaurus** for open-source projects. Use **Storybook** for component libraries.
+
+## Orchestration & Integration
+- `openapi-swagger-codegen-expert`, `design-system-architect`, `seo`
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk membangun situs dokumentasi teknis dan library komponen. Mencakup Mintlify, Docusaurus 3, Storybook 8, VitePress, dan Astro Starlight.
+
+### Kondisi Pemicu
+- Membuat situs dokumentasi untuk API, library, atau produk.
+- Menyiapkan Storybook untuk dokumentasi komponen.
+- Memilih framework dokumentasi.

package/skills/doku-mcp-server/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: doku-mcp-server
 description: "Expert guide for DOKU Model Context Protocol (MCP) Server integration. Enables AI Agentic Commerce with tools for payment links, Virtual Accounts, QRIS, transaction status checks, and client configuration (Claude Desktop, Cursor, AGY) / Panduan ahli DOKU MCP Server untuk AI Agentic Commerce."
-author: "Roedy Rustam"
+author: "Roedy Rustam"
 ---
 
 # DOKU MCP Server / Server Model Context Protocol DOKU
@@ -13,6 +13,9 @@ author: "Roedy Rustam"
 <a name="english"></a>
 ## English
 
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
 ### Description
 Expert guide for integrating and building Model Context Protocol (MCP) servers with DOKU Payment Gateway based on [DOKU Developers Documentation](https://developers.doku.com/). Enables AI Agents (Claude Desktop, Antigravity, Cursor, n8n, LangChain) to execute payment tasks autonomously using Agentic Commerce capabilities (generating payment links, issuing Virtual Account numbers, generating QRIS codes, querying transaction statuses).
 
@@ -206,6 +209,9 @@ main().catch(console.error);
 <a name="bahasa-indonesia"></a>
 ## Bahasa Indonesia
 
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
 ### Deskripsi
 Panduan ahli untuk mengintegrasikan dan membuat server Model Context Protocol (MCP) dengan DOKU Payment Gateway berdasarkan dokumentasi resmi [DOKU Developers Documentation](https://developers.doku.com/). Memungkinkan Agen AI (Claude Desktop, Antigravity, Cursor, n8n, LangChain) menjalankan transaksi pembayaran secara otonom dalam alur Agentic Commerce (membuat link pembayaran, membuat nomor Virtual Account, membuat kode QRIS, dan memeriksa status transaksi).
 

package/skills/doku-payment-gateway/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: doku-payment-gateway
 description: "Expert guide for integrating DOKU Payment Gateway (Jokul API v2). Covers HMAC-SHA256 header signature calculation, Checkout & Direct APIs (VA, QRIS, E-Wallet, Credit Card), webhook notification verification, and sandbox/production setup / Panduan ahli integrasi DOKU Payment Gateway."
-author: "Roedy Rustam"
+author: "Roedy Rustam"
 ---
 
 # DOKU Payment Gateway Integration / Integrasi Payment Gateway DOKU
@@ -13,6 +13,9 @@ author: "Roedy Rustam"
 <a name="english"></a>
 ## English
 
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
 ### Description
 Expert guide for implementing DOKU Payment Gateway (Jokul API v2) integrations based on official [DOKU Developers Documentation](https://developers.doku.com/). Covers authentication headers, SHA-256 Digest generation, HMAC-SHA256 request signature construction, Webhook notification verification, Checkout Payment Links, Direct Payments (Virtual Account, QRIS, E-Wallet, Credit Card), error handling, and sandbox/production deployment.
 
@@ -197,6 +200,9 @@ export function verifyDokuWebhook(req: Request, secretKey: string): boolean {
 <a name="bahasa-indonesia"></a>
 ## Bahasa Indonesia
 
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
 ### Deskripsi
 Panduan ahli untuk mengintegrasikan DOKU Payment Gateway (Jokul API v2) sesuai standar dokumentasi resmi [DOKU Developers Portal](https://developers.doku.com/). Mencakup header autentikasi, pembuatan Digest SHA-256, pembuatan Signature HMAC-SHA256, verifikasi Webhook/Notifikasi, Checkout Payment Link, Direct Payment (Virtual Account, QRIS, E-Wallet, Kartu Kredit), penanganan error, dan migrasi Sandbox ke Production.
 

package/skills/domain-driven-design-expert/SKILL.md

@@ -0,0 +1,82 @@
+---
+name: domain-driven-design-expert
+description: "Expert guide for Domain-Driven Design (DDD). Covers tactical patterns (Aggregates, Value Objects), strategic patterns (Bounded Contexts), event storming, and CQRS / Panduan ahli Desain Berbasis Domain (DDD)."
+author: "Roedy Rustam"
+---
+
+# Domain-Driven Design (DDD) Expert
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+A software architecture guide focused on tackling complexity in the heart of software. This skill bridges the gap between business rules and codebase structure using Domain-Driven Design (DDD). It covers Strategic Design (Bounded Contexts, Ubiquitous Language) and Tactical Design (Aggregates, Value Objects, Domain Events, Repositories).
+
+### Trigger Conditions
+- When refactoring a massive, monolithic "Big Ball of Mud" codebase.
+- When defining microservice boundaries (Bounded Contexts).
+- When the user asks about "Clean Architecture", "CQRS", or "Event Sourcing".
+- When building core business logic that is highly complex and rule-heavy (e.g., banking, logistics, SaaS billing engines).
+
+### Core Architectural Guidelines
+
+#### 1. Strategic Design (The Big Picture)
+- **Ubiquitous Language**: The code must speak the language of the business. Do not use generic terms like `UserData` if the business calls it a `Subscriber`.
+- **Bounded Contexts**: Divide large systems into distinct contexts. A `Product` in the Inventory context has different attributes than a `Product` in the Billing context. Do not try to create one massive, unified `Product` model.
+
+#### 2. Tactical Design (The Code)
+- **Value Objects**: Use immutable Value Objects for attributes (e.g., `Money`, `Address`, `Email`) instead of primitives (`int`, `string`). Value Objects validate themselves upon creation.
+- **Entities & Aggregates**: Group related Entities together under a single Aggregate Root. External objects may only hold a reference to the Aggregate Root, never to its internal children.
+- **Repositories**: Only create Repositories for Aggregate Roots.
+
+#### 3. Domain Events
+When an Aggregate changes state in a way that other parts of the system care about, it should publish a Domain Event (e.g., `OrderPlacedEvent`). This decouples side-effects (like sending an email) from the core business transaction.
+
+#### 4. CQRS (Command Query Responsibility Segregation)
+For highly scalable systems, separate the models used for writing data (Commands) from the models used for reading data (Queries).
+- **Commands**: Modify state via the rich Domain Model.
+- **Queries**: Read data directly from optimized database views or read models, bypassing the Domain Model entirely for performance.
+
+## Orchestration & Integration
+- Extends `scalability-clean-code` with strict domain isolation patterns.
+- Essential for `event-driven-architect` when defining what events flow through the message broker.
+- Complements `micro-frontend-architect` by aligning frontend boundaries with backend Bounded Contexts.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan arsitektur perangkat lunak yang berfokus pada penanganan kompleksitas bisnis. Skill ini menjembatani aturan bisnis dan struktur kode menggunakan Domain-Driven Design (DDD). Meliputi Desain Strategis (Bounded Contexts, Ubiquitous Language) dan Desain Taktis (Aggregates, Value Objects, Domain Events).
+
+### Kondisi Pemicu
+- Saat melakukan refactoring codebase monolitik yang sudah berantakan (Big Ball of Mud).
+- Saat mendefinisikan batas-batas layanan microservices.
+- Saat membangun logika bisnis inti yang sangat kompleks (misal: mesin penagihan SaaS, sistem perbankan).
+
+### Panduan Arsitektur Inti
+
+#### 1. Desain Strategis
+- **Ubiquitous Language**: Kode harus menggunakan bahasa yang sama dengan pihak bisnis. Hindari istilah teknis generik jika ada istilah bisnis yang lebih tepat.
+- **Bounded Contexts**: Jangan mencoba membuat satu model data raksasa (misal: tabel `User` dengan 100 kolom). Pisahkan berdasarkan konteks; entitas `User` di konteks Penagihan berbeda dengan `User` di konteks Pengiriman.
+
+#### 2. Desain Taktis (Implementasi Kode)
+- **Value Objects**: Gunakan objek *immutable* (tidak dapat diubah) untuk atribut seperti `Uang`, `Alamat`, atau `Email` daripada tipe data primitif biasa (string/int).
+- **Aggregates**: Kelompokkan entitas-entitas yang saling berhubungan ke dalam satu Aggregate Root. Interaksi dari luar hanya boleh melalui Root ini untuk menjaga konsistensi data.
+- **Repositories**: Buat Repository hanya untuk Aggregate Root, bukan untuk setiap tabel di database.
+
+#### 3. Domain Events
+Pisahkan efek samping (side-effects). Daripada membuat modul Pesanan memanggil modul Email secara langsung, buat modul Pesanan menerbitkan `OrderPlacedEvent`. Modul Email akan bereaksi terhadap event tersebut.
+
+#### 4. CQRS
+Pisahkan model data untuk operasi *Write* (Command) dan *Read* (Query). Model baca dapat dioptimalkan secara drastis dengan melakukan bypass penuh pada logika domain.
+
+## Integrasi Orkestrasi
+- Mengembangkan `scalability-clean-code` dengan pola isolasi domain yang ketat.
+- Sangat penting bagi `event-driven-architect` untuk menentukan struktur event di message broker.
+- Membantu `micro-frontend-architect` menyelaraskan batas-batas frontend dengan Bounded Contexts backend.

package/skills/e2e-testing-expert/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: e2e-testing-expert
 description: "Expert guide for End-to-End (E2E) testing with Playwright, unit/integration testing with Vitest, and CI/CD automated testing pipeline setup / Panduan ahli pengujian End-to-End (E2E) dengan Playwright, pengujian unit/integrasi dengan Vitest, dan otomatisasi CI/CD."
-author: "Roedy Rustam"
+author: "Roedy Rustam"
 ---
 
 # E2E Testing Expert (Playwright 1.49+ / Vitest 3 Edition)
@@ -13,6 +13,9 @@ author: "Roedy Rustam"
 <a name="english"></a>
 ## English
 
+### Orchestration & Integration
+Connects and orchestrates with relevant domain skills like `brainstorming`, `zero-to-prod-orchestrator`, and `project-context-mapper` to ensure cohesive execution.
+
 ### Description
 Expert guide for building comprehensive automated test suites using **Playwright 1.49+** (E2E + component testing), **Vitest 3** (unit/integration), and robust CI/CD pipelines. Covers modern testing patterns for Next.js 15, React 19, and API backends.
 
@@ -279,6 +282,9 @@ jobs:
 <a name="bahasa-indonesia"></a>
 ## Bahasa Indonesia
 
+### Integrasi Orkestrasi
+Terhubung dan mengorkestrasi skill domain yang relevan seperti `brainstorming`, `zero-to-prod-orchestrator`, dan `project-context-mapper` untuk memastikan eksekusi yang kohesif.
+
 ### Deskripsi
 Panduan ahli untuk membangun test suite otomatis yang komprehensif menggunakan **Playwright 1.49+** (E2E + component testing), **Vitest 3** (unit/integrasi), dan pipeline CI/CD yang kuat. Mencakup pola pengujian modern untuk Next.js 15, React 19, dan backend API.
 

package/skills/ecommerce-expert/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: ecommerce-expert
+description: "Expert guide for e-commerce architecture (Shopify Storefront, Medusa.js, Saleor), product catalogs, cart/checkout UX, and order management / Panduan ahli arsitektur e-commerce (Shopify, Medusa.js, Saleor), katalog produk, UX keranjang/checkout, dan manajemen pesanan."
+author: "Roedy Rustam"
+---
+
+# E-Commerce Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Orchestration & Integration
+- **`payment-gateway-expert`**: Stripe, Xendit, Midtrans payment integration.
+- **`nextjs-app-router-expert`**: SSR product pages and cart functionality.
+- **`seo`**: Product schema markup, sitemaps, and SEO optimization.
+- **`saas-billing`**: Subscription-based e-commerce models.
+- **`headless-cms-expert`**: Content management for product descriptions and pages.
+
+### Description
+Expert guide for building modern e-commerce applications. Covers Shopify Storefront API (headless commerce), Medusa.js v2 (open-source, self-hosted), Saleor (GraphQL-first), product catalog design, cart state management, checkout flows, inventory management, order fulfillment, and SEO for product pages.
+
+### Trigger Conditions
+- Building an online store or e-commerce platform.
+- Integrating Shopify Storefront API with custom frontend.
+- Setting up Medusa.js or Saleor for headless commerce.
+- Designing product catalog schemas and cart/checkout UX.
+
+---
+
+### Platform Selection
+
+| Platform | Type | API | Self-Hosted | Best For |
+|----------|------|-----|-------------|----------|
+| Shopify Storefront | SaaS + Headless | GraphQL | ❌ | Quick launch, large catalog |
+| Medusa.js v2 | Open-source | REST + JS SDK | ✅ | Full control, customization |
+| Saleor | Open-source | GraphQL | ✅ | Enterprise, multi-channel |
+| WooCommerce | Plugin (WordPress) | REST | ✅ | WordPress ecosystem |
+
+### Core Patterns
+
+```typescript
+// Shopify Storefront API — Fetch products
+const SHOPIFY_QUERY = `{
+  products(first: 12, sortKey: BEST_SELLING) {
+    edges {
+      node {
+        id title handle description
+        priceRange { minVariantPrice { amount currencyCode } }
+        images(first: 1) { edges { node { url altText } } }
+        variants(first: 5) { edges { node { id title availableForSale price { amount } } } }
+      }
+    }
+  }
+}`;
+
+async function getProducts() {
+  const res = await fetch(process.env.SHOPIFY_STOREFRONT_URL!, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'X-Shopify-Storefront-Access-Token': process.env.SHOPIFY_TOKEN!,
+    },
+    body: JSON.stringify({ query: SHOPIFY_QUERY }),
+  });
+  return (await res.json()).data.products.edges.map((e) => e.node);
+}
+```
+
+## Orchestration & Integration
+- `payment-gateway-expert`, `nextjs-app-router-expert`, `seo`, `saas-billing`
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan ahli untuk membangun aplikasi e-commerce modern. Mencakup Shopify Storefront API, Medusa.js v2, Saleor, desain katalog produk, manajemen keranjang, alur checkout, manajemen inventaris, dan SEO halaman produk.
+
+### Kondisi Pemicu
+- Membangun toko online atau platform e-commerce.
+- Mengintegrasikan Shopify Storefront API dengan frontend kustom.
+- Menyiapkan Medusa.js atau Saleor untuk headless commerce.

package/skills/edge-serverless-db-expert/SKILL.md

@@ -1,43 +1,99 @@
----
-name: edge-serverless-db-expert
-description: "Expert guide for Serverless & Edge Databases (Neon Serverless Postgres, Cloudflare D1, Turso/libsql, Upstash Redis), cold-start mitigation, and connection pooling / Panduan ahli database Serverless & Edge (Neon, Cloudflare D1, Turso, Upstash)."
+---
+name: edge-serverless-db-expert
+description: "Expert guide for Serverless & Edge Databases (Neon Serverless Postgres, Cloudflare D1, Turso/libsql, Upstash Redis), cold-start mitigation, and connection pooling / Panduan ahli database Serverless & Edge (Neon, Cloudflare D1, Turso, Upstash)."
 author: "Roedy Rustam"
----
-
-# Edge & Serverless DB Expert
-
-[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
-
----
-
-<a name="english"></a>
-## English
-
-### Purpose & Overview
-Best practices for building ultra-low-latency applications powered by serverless and edge databases — Neon Serverless Postgres, Cloudflare D1 (SQLite at Edge), Turso (libsql distributed SQLite), Upstash Serverless Redis & Vector, HTTP connection pooling via Hyperdrive/Prisma Accelerate, and zero-cold-start strategies.
-
-### Key Capabilities
-- **Neon & Cloudflare D1**: Serverless autoscaling Postgres with instant branching and distributed edge SQLite.
-- **Connection Pooling**: WebSocket/HTTP proxy pooling (Neon Serverless Driver, Upstash Redis over HTTP) for edge workers without TCP pool exhaustion.
-- **Embedded Replicas**: Syncing edge SQLite read-replicas with central cloud databases for sub-10ms queries.
-
-```typescript
-import { neon } from '@neondatabase/serverless';
-import { drizzle } from 'drizzle-orm/neon-http';
-
-const sql = neon(process.env.DATABASE_URL!);
-export const db = drizzle({ client: sql });
-```
-
----
-
-<a name="bahasa-indonesia"></a>
-## Bahasa Indonesia
-
-### Deskripsi
-Praktik terbaik membangun aplikasi latensi rendah dengan database serverless dan edge — Neon Serverless Postgres, Cloudflare D1 (SQLite di Edge), Turso (libsql terdistribusi), Upstash Serverless Redis & Vector, connection pooling HTTP/WebSocket, dan mitigasi cold-start.
-
-### Fitur Utama
-- **Neon & Cloudflare D1**: Serverless Postgres autoscaling dengan branching instan dan distributed edge SQLite.
-- **Connection Pooling**: Proxy pooling HTTP/WebSocket untuk edge worker tanpa risiko kehabisan koneksi TCP.
-- **Embedded Replicas**: Sinkronisasi read-replica SQLite di edge dengan database utama untuk query di bawah 10ms.
+---
+
+# Edge & Serverless DB Expert
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Purpose & Overview
+Best practices for building ultra-low-latency 2026/2027 applications powered by serverless and edge databases. Exploit Neon Serverless Postgres, Cloudflare D1, Turso, Upstash Serverless Redis & Vector. Implement zero-cold-start strategies and HTTP connection pooling.
+
+### Key Capabilities
+- **Neon & Cloudflare D1**: Serverless autoscaling Postgres with instant branching. Distributed edge SQLite.
+- **Connection Pooling**: WebSocket/HTTP proxy pooling (Neon Serverless Driver, Upstash Redis over HTTP) for edge workers. Prevent TCP pool exhaustion.
+- **Embedded Replicas**: Sync edge SQLite read-replicas with central cloud databases for sub-10ms queries.
+
+```typescript
+import { neon } from '@neondatabase/serverless';
+import { drizzle } from 'drizzle-orm/neon-http';
+
+const sql = neon(process.env.DATABASE_URL!);
+export const db = drizzle({ client: sql });
+```
+
+### Implementation Checklist
+- [ ] Use HTTP/WebSocket drivers (e.g., `neon-http`) for querying databases from Edge Workers/Functions.
+- [ ] Configure connection pooling (PgBouncer, Prisma Accelerate) for standard TCP connections to avoid exhausting database connection limits.
+- [ ] Use read-replicas near the edge location for global deployments to minimize latency.
+- [ ] Cache read-heavy queries at the edge using Upstash Redis or Cloudflare KV.
+
+### Example: Upstash Redis Edge Caching
+```typescript
+import { Redis } from '@upstash/redis';
+
+const redis = new Redis({
+  url: process.env.UPSTASH_REDIS_REST_URL!,
+  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
+});
+
+export async function getCachedData(key: string) {
+  let data = await redis.get(key);
+  if (!data) {
+    data = await fetchFromDB();
+    await redis.set(key, data, { ex: 3600 }); // Cache for 1 hour
+  }
+  return data;
+}
+```
+
+## Orchestration & Integration
+- Integrates with: `database-orm-expert`, `js-backend-expert`, `cloud-hosting-expert`.
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Praktik terbaik membangun aplikasi latensi rendah 2026/2027 dengan database serverless dan edge. Manfaatkan Neon Serverless Postgres, Cloudflare D1, Turso, Upstash Serverless Redis & Vector. Implementasi strategi tanpa cold-start dan connection pooling HTTP.
+
+### Fitur Utama
+- **Neon & Cloudflare D1**: Serverless Postgres autoscaling dengan branching instan. Distributed edge SQLite.
+- **Connection Pooling**: Proxy pooling HTTP/WebSocket untuk edge worker. Cegah kehabisan koneksi TCP.
+- **Embedded Replicas**: Sinkronisasi read-replica SQLite di edge dengan database utama untuk query di bawah 10ms.
+
+### Checklist Implementasi
+- [ ] Gunakan driver HTTP/WebSocket (misal: `neon-http`) untuk mengakses database dari Edge Workers/Functions.
+- [ ] Konfigurasi connection pooling (PgBouncer, Prisma Accelerate) pada koneksi TCP standar untuk mencegah batas koneksi habis.
+- [ ] Gunakan read-replicas di dekat lokasi edge untuk deployment global guna meminimalkan latensi.
+- [ ] Cache query berat di edge menggunakan Upstash Redis atau Cloudflare KV.
+
+### Contoh: Upstash Redis Edge Caching
+```typescript
+import { Redis } from '@upstash/redis';
+
+const redis = new Redis({
+  url: process.env.UPSTASH_REDIS_REST_URL!,
+  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
+});
+
+export async function getCachedData(key: string) {
+  let data = await redis.get(key);
+  if (!data) {
+    data = await fetchFromDB();
+    await redis.set(key, data, { ex: 3600 }); // Cache 1 jam
+  }
+  return data;
+}
+```
+
+## Integrasi Orkestrasi
+- Terintegrasi dengan: `database-orm-expert`, `js-backend-expert`, `cloud-hosting-expert`.