vibes-plug 1.0.0

package/skills/go-programming-expert/SKILL.md

@@ -0,0 +1,295 @@
+---
+name: go-programming-expert
+description: "Expert-level skill for Go programming (Go 1.23/1.24+). Covers high-performance microservices, concurrency patterns, sqlc, net/http, Gin/Echo/Fiber, gRPC, and testing in English and Indonesian."
+author: "Roedy Rustam"
+---
+
+# Go Programming Expert (Go 1.24 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Expert-level Go development for building high-performance microservices, APIs, and CLI tools. Covers **Go 1.24** features (range-over-func iterators, generic type aliases, weak pointers), structured logging with `slog`, `net/http` with the new ServeMux patterns, Gin/Echo/Fiber frameworks, sqlc for type-safe SQL, gRPC, and production testing patterns.
+
+### Trigger Conditions
+- Writing Go 1.23+ / 1.24+ microservices or APIs.
+- Implementing concurrency patterns with goroutines, channels, and `sync` primitives.
+- Using structured logging with `log/slog`.
+- Building HTTP servers with `net/http` ServeMux (Go 1.22+) or Gin/Echo/Fiber.
+- Writing type-safe SQL with **sqlc** or using **GORM**.
+- Implementing gRPC services with protobuf.
+- Writing Go tests with the standard `testing` package + `testify`.
+
+### Go 1.24 — Key Features
+
+#### Range-Over-Func (Go 1.22 → Stable in 1.24)
+Range over custom iterators — enables functional-style collection operations:
+```go
+// Define an iterator function
+func Fibonacci() iter.Seq[int] {
+    return func(yield func(int) bool) {
+        a, b := 0, 1
+        for {
+            if !yield(a) {
+                return
+            }
+            a, b = b, a+b
+        }
+    }
+}
+
+// Range over it naturally
+for n := range Fibonacci() {
+    if n > 100 {
+        break
+    }
+    fmt.Println(n)
+}
+```
+
+#### Generic Type Aliases (Go 1.24)
+```go
+// Type alias with generic parameters
+type Set[T comparable] = map[T]struct{}
+type Result[T any] = struct{ Value T; Err error }
+
+// Usage
+var s Set[string] = make(map[string]struct{})
+```
+
+#### Weak Pointers (Go 1.24)
+```go
+import "weak"
+
+// Weak pointer — does not prevent GC collection
+ptr := weak.Make(&myStruct{})
+if val := ptr.Value(); val != nil {
+    // Still alive
+}
+```
+
+### Structured Logging with `log/slog`
+```go
+package main
+
+import (
+    "log/slog"
+    "os"
+)
+
+func main() {
+    // Production JSON logger
+    logger := slog.New(slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
+        Level: slog.LevelInfo,
+        AddSource: true, // include file:line
+    }))
+    slog.SetDefault(logger)
+
+    slog.Info("server started", "port", 8080, "env", "production")
+    slog.Error("database connection failed", "error", err, "host", dbHost)
+    
+    // Grouped context
+    reqLogger := logger.WithGroup("request").With(
+        "trace_id", traceID,
+        "user_id", userID,
+    )
+    reqLogger.Info("handler called", "method", r.Method, "path", r.URL.Path)
+}
+```
+
+### HTTP Server — net/http ServeMux (Go 1.22+)
+Go 1.22 upgraded the standard ServeMux with method-based routing and path parameters — reducing the need for external routers:
+```go
+package main
+
+import (
+    "encoding/json"
+    "net/http"
+    "log/slog"
+)
+
+func main() {
+    mux := http.NewServeMux()
+
+    // Method + path pattern matching (Go 1.22+)
+    mux.HandleFunc("GET /api/users", listUsers)
+    mux.HandleFunc("POST /api/users", createUser)
+    mux.HandleFunc("GET /api/users/{id}", getUser)  // path params
+    mux.HandleFunc("DELETE /api/users/{id}", deleteUser)
+
+    slog.Info("starting server", "addr", ":8080")
+    http.ListenAndServe(":8080", mux)
+}
+
+func getUser(w http.ResponseWriter, r *http.Request) {
+    id := r.PathValue("id")  // Extract path parameter
+    // ...
+    w.Header().Set("Content-Type", "application/json")
+    json.NewEncoder(w).Encode(user)
+}
+```
+
+### Type-Safe SQL with sqlc
+```bash
+# Install sqlc
+go install github.com/sqlc-dev/sqlc/cmd/sqlc@latest
+
+# sqlc.yaml
+version: "2"
+sql:
+  - engine: "postgresql"
+    queries: "queries/"
+    schema: "schema/"
+    gen:
+      go:
+        package: "db"
+        out: "internal/db"
+        emit_json_tags: true
+        emit_interface: true
+```
+
+```sql
+-- queries/users.sql
+-- name: GetUser :one
+SELECT * FROM users WHERE id = $1 LIMIT 1;
+
+-- name: ListUsers :many
+SELECT * FROM users ORDER BY created_at DESC LIMIT $1 OFFSET $2;
+
+-- name: CreateUser :one
+INSERT INTO users (name, email) VALUES ($1, $2) RETURNING *;
+```
+
+```go
+// Generated type-safe Go code (used in handlers)
+user, err := queries.GetUser(ctx, userID) // Fully typed!
+users, err := queries.ListUsers(ctx, db.ListUsersParams{Limit: 20, Offset: 0})
+```
+
+### Concurrency Patterns
+
+#### errgroup for Parallel Work
+```go
+import "golang.org/x/sync/errgroup"
+
+g, ctx := errgroup.WithContext(context.Background())
+
+g.Go(func() error { return fetchA(ctx) })
+g.Go(func() error { return fetchB(ctx) })
+
+if err := g.Wait(); err != nil {
+    // First error from any goroutine
+    return fmt.Errorf("parallel fetch: %w", err)
+}
+```
+
+#### Worker Pool Pattern
+```go
+func workerPool(jobs <-chan Job, results chan<- Result, numWorkers int) {
+    var wg sync.WaitGroup
+    for range numWorkers {
+        wg.Add(1)
+        go func() {
+            defer wg.Done()
+            for job := range jobs {
+                results <- process(job)
+            }
+        }()
+    }
+    wg.Wait()
+    close(results)
+}
+```
+
+### Testing Best Practices
+```go
+package user_test
+
+import (
+    "testing"
+    "github.com/stretchr/testify/assert"
+    "github.com/stretchr/testify/require"
+)
+
+func TestGetUser(t *testing.T) {
+    t.Parallel() // Always parallelize independent tests
+
+    // Table-driven tests
+    tests := []struct{
+        name   string
+        userID string
+        want   *User
+        wantErr bool
+    }{
+        {"valid user", "user-123", &User{ID: "user-123"}, false},
+        {"not found", "missing", nil, true},
+    }
+
+    for _, tt := range tests {
+        t.Run(tt.name, func(t *testing.T) {
+            t.Parallel()
+            got, err := GetUser(context.Background(), tt.userID)
+            if tt.wantErr {
+                require.Error(t, err)
+                return
+            }
+            require.NoError(t, err)
+            assert.Equal(t, tt.want.ID, got.ID)
+        })
+    }
+}
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan Go tingkat ahli untuk membangun microservices, API, dan CLI tool berkinerja tinggi. Mencakup fitur **Go 1.24** (range-over-func, generic type alias, weak pointer), structured logging dengan `slog`, ServeMux `net/http` dengan pola baru (Go 1.22+), framework Gin/Echo/Fiber, sqlc untuk SQL type-safe, gRPC, dan pola pengujian produksi.
+
+### Kondisi Pemicu
+- Menulis microservices atau API Go 1.23+/1.24+.
+- Mengimplementasikan pola konkurensi dengan goroutine, channel, dan primitif `sync`.
+- Menggunakan structured logging dengan `log/slog`.
+- Membangun HTTP server dengan ServeMux `net/http` (Go 1.22+) atau Gin/Echo/Fiber.
+- Menulis SQL type-safe dengan **sqlc** atau GORM.
+- Mengimplementasikan layanan gRPC dengan protobuf.
+
+### Go 1.24 — Fitur Utama
+
+#### Range-Over-Func (Stabil di 1.24)
+Go 1.24 menstabilkan range over iterator function — memungkinkan koleksi gaya fungsional yang idiomatis tanpa mengekspos slice internal.
+
+#### Generic Type Alias
+Go 1.24 memungkinkan alias tipe dengan parameter generic, meningkatkan komposibilitas tipe.
+
+#### Weak Pointer
+`weak.Make()` membuat pointer lemah yang tidak mencegah GC mengumpulkan objek — berguna untuk cache.
+
+### Structured Logging dengan `log/slog`
+Paket `log/slog` bawaan Go (sejak 1.21) mendukung output JSON terstruktur, level log, dan pengelompokan atribut. Gunakan sebagai standar logging di semua proyek Go baru.
+
+### HTTP Server — net/http ServeMux (Go 1.22+)
+ServeMux Go 1.22 mendukung pencocokan berdasarkan metode HTTP dan parameter path — mengurangi kebutuhan router eksternal untuk API sederhana.
+
+### SQL Type-Safe dengan sqlc
+`sqlc` menghasilkan kode Go yang fully typed dari query SQL dan skema database — menghilangkan kebutuhan ORM untuk sebagian besar kasus.
+
+### Pola Konkurensi
+
+#### errgroup
+Gunakan `errgroup.WithContext()` dari `golang.org/x/sync/errgroup` untuk menjalankan goroutine paralel dan mengumpulkan error pertama secara aman.
+
+#### Worker Pool
+Gunakan pola worker pool dengan channel untuk memproses pekerjaan secara paralel dengan jumlah goroutine yang terkendali.
+
+### Best Practices Pengujian
+- Gunakan `t.Parallel()` untuk semua test independen.
+- Gunakan table-driven tests untuk menguji banyak skenario dengan kode minimal.
+- Gunakan `testify/assert` dan `testify/require` untuk assertion yang ekspresif.

package/skills/hig/SKILL.md

@@ -0,0 +1,188 @@
+---
+name: hig
+description: "Applies Human Interface Guidelines (HIG) principles — Hierarchy, Harmony, and Consistency — to UI/UX designs to ensure intuitive and cohesive interfaces / Menerapkan prinsip Human Interface Guidelines (HIG) — Hierarchy, Harmony, dan Consistency — pada desain UI/UX untuk memastikan antarmuka yang intuitif dan kohesif."
+author: "Roedy Rustam"
+---
+
+# Human Interface Guidelines (HIG) Expert (2026 Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Applies Human Interface Guidelines (HIG) principles to web and mobile UI/UX designs. Covers the core triad (Hierarchy, Harmony, Consistency), Apple's HIG 2025 updates, Google Material Design 3, spatial design for Apple Vision Pro, and modern accessibility requirements.
+
+### Trigger Conditions
+- Reviewing or critiquing a UI design for HIG violations.
+- Making design decisions about typography scale, color usage, or layout hierarchy.
+- Designing for multiple platforms (iOS, Android, web) with consistent patterns.
+- Evaluating whether a UI feels "premium" or "amateur".
+- Ensuring UI components follow platform conventions (button placement, nav patterns).
+
+### The Core HIG Triad
+
+#### 1. Hierarchy — Guide the User's Eye
+Visual hierarchy controls where the user looks first and how they navigate information.
+
+**Typography Hierarchy:**
+```css
+/* Clear hierarchy with size and weight — 4 levels max */
+.h1 { font-size: 2.25rem; font-weight: 700; letter-spacing: -0.02em; }
+.h2 { font-size: 1.5rem;  font-weight: 600; letter-spacing: -0.01em; }
+.h3 { font-size: 1.25rem; font-weight: 600; }
+.body { font-size: 1rem;    font-weight: 400; }
+.caption { font-size: 0.875rem; font-weight: 400; color: var(--color-text-muted); }
+```
+
+**Spatial Hierarchy (Z-axis):**
+- Surface level: cards, panels — `shadow-sm`
+- Raised level: dropdowns, tooltips — `shadow-md`
+- Overlay level: modals, drawers — `shadow-xl`
+- Floating level: toasts, command palette — `shadow-2xl`
+
+**Color Hierarchy:**
+- Primary action: brand color (1 per screen)
+- Secondary action: muted/ghost variant
+- Destructive action: red — far from primary CTA
+
+#### 2. Harmony — Visual Cohesion
+All elements should feel like they belong to the same family.
+
+**Spacing Scale (8pt Grid):**
+```
+4px   → xs gaps (icon padding, tight list items)
+8px   → sm (between related elements)
+16px  → md (card padding, section spacing)
+24px  → lg (between sections)
+32px  → xl (between major blocks)
+48px  → 2xl (page-level separation)
+```
+
+**Border Radius Consistency:**
+- Small elements (badges, chips): `rounded-full` or `rounded-sm`
+- Medium elements (inputs, buttons): `rounded-md`
+- Large elements (cards, modals): `rounded-xl`
+- Never mix `rounded-none` with `rounded-2xl` in the same screen
+
+**Color Harmony:**
+```
+Analogous:     Brand + ±30° hue neighbors (natural, calm)
+Complementary: Brand + 180° (high contrast, CTAs)
+Triadic:       Brand + 120°/240° (vibrant, use sparingly)
+Monochromatic: Single hue, varying lightness (professional)
+```
+
+#### 3. Consistency — Reduce Cognitive Load
+Users should never wonder "how does this work?" — patterns should be predictable.
+
+**Platform Conventions (Web):**
+- Primary CTA: top-right (desktop nav) or bottom-center (mobile)
+- Destructive actions: always require confirmation dialogs
+- Form submission: Enter key submits, Escape cancels/closes
+- Navigation: Breadcrumbs for 3+ depth levels
+- Empty states: Always provide an actionable CTA
+
+**Component Consistency Checklist:**
+- [ ] All buttons use the same radius (`rounded-md` everywhere).
+- [ ] All modals have the same padding (`p-6`) and close behavior (Escape key).
+- [ ] All form inputs have the same height (`h-9`) and focus ring style.
+- [ ] All error messages appear in the same position (below the input field).
+- [ ] All tables use the same row height and hover style.
+
+### Apple HIG 2025 Updates
+
+#### Spatial Design (Vision Pro)
+- Use **depth** as an organizational tool — foreground elements are more important.
+- Avoid placing interactive elements outside comfortable viewing angles (±45° center).
+- Use **glass morphism** (`backdrop-blur`) for panels to maintain spatial context.
+- Prefer indirect input (gaze + pinch) over precise pointer interactions.
+
+#### iOS 18 Design Patterns
+- **Liquid Glass**: Full glass-morphism on navigation bars and toolbars.
+- **Adaptive layouts**: Single codebase adapts from iPhone to iPad to Mac.
+- **Symbols**: SF Symbols 6 with variable rendering (multicolor, hierarchical).
+- **Menu patterns**: Context menus replace modal bottom sheets where possible.
+
+### Material Design 3 (Google)
+
+#### Dynamic Color (M3)
+Generate a full color system from a single seed color:
+```typescript
+import { argbFromHex, themeFromSourceColor } from '@material/material-color-utilities';
+
+const theme = themeFromSourceColor(argbFromHex('#6750A4'));
+// Generates: primary, secondary, tertiary, error + all tonal palettes
+```
+
+#### Key M3 Components
+- **Cards**: 3 variants — Elevated (shadow), Filled (surface variant), Outlined (border)
+- **Chips**: Filter, Input, Suggestion, Assist — each with distinct purpose
+- **Navigation**: Bottom bar (≤5 items), Rail (tablet), Drawer (desktop)
+
+### HIG Audit Protocol
+When reviewing a design, check:
+1. **Hierarchy**: Is the primary action immediately obvious? Is text contrast sufficient?
+2. **Harmony**: Is spacing consistent (8pt grid)? Are border radii uniform?
+3. **Consistency**: Do interactive elements follow platform conventions?
+4. **Accessibility**: Does it pass WCAG 2.2? Are touch targets ≥ 24×24px?
+5. **Platform fit**: Does it feel native to its target platform?
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Menerapkan prinsip Human Interface Guidelines (HIG) pada desain UI/UX web dan mobile. Mencakup triad inti (Hierarchy, Harmony, Consistency), pembaruan Apple HIG 2025, Google Material Design 3, desain spasial untuk Apple Vision Pro, dan persyaratan aksesibilitas modern.
+
+### Kondisi Pemicu
+- Meninjau atau mengkritik desain UI untuk pelanggaran HIG.
+- Membuat keputusan desain tentang skala tipografi, penggunaan warna, atau hierarki tata letak.
+- Merancang untuk berbagai platform (iOS, Android, web) dengan pola yang konsisten.
+- Mengevaluasi apakah UI terasa "premium" atau "amatir".
+- Memastikan komponen UI mengikuti konvensi platform.
+
+### Triad HIG Inti
+
+#### 1. Hierarki — Pandu Mata Pengguna
+Hierarki visual mengontrol di mana pengguna melihat pertama dan bagaimana mereka menavigasi informasi.
+- **Hierarki tipografi**: 4 level maksimal — H1 (2.25rem, 700), H2 (1.5rem, 600), H3 (1.25rem, 600), body (1rem, 400).
+- **Hierarki spasial (sumbu-Z)**: Surface (shadow-sm), Raised (shadow-md), Overlay (shadow-xl), Floating (shadow-2xl).
+- **Hierarki warna**: Satu warna brand per layar, aksi sekunder dengan varian muted/ghost, aksi destruktif dengan merah — jauh dari CTA utama.
+
+#### 2. Harmoni — Kohesi Visual
+Semua elemen harus terasa seperti milik keluarga yang sama.
+- **Skala spacing (grid 8pt)**: 4px, 8px, 16px, 24px, 32px, 48px.
+- **Konsistensi border radius**: Elemen kecil (rounded-full), sedang (rounded-md), besar (rounded-xl). Jangan campurkan rounded-none dengan rounded-2xl di layar yang sama.
+- **Harmoni warna**: Analogis, komplementer, triadik, atau monokromatik — pilih satu skema dan patuhi.
+
+#### 3. Konsistensi — Kurangi Beban Kognitif
+Pengguna tidak pernah bertanya-tanya "bagaimana cara ini bekerja?" — pola harus dapat diprediksi.
+- Konvensi platform: CTA utama di kanan atas (nav desktop) atau bawah tengah (mobile).
+- Aksi destruktif selalu memerlukan dialog konfirmasi.
+- Semua komponen sejenis menggunakan radius, padding, dan perilaku yang sama.
+
+### Pembaruan Apple HIG 2025
+
+#### Desain Spasial (Vision Pro)
+Gunakan kedalaman sebagai alat organisasi. Gunakan glass-morphism (`backdrop-blur`) untuk panel. Hindari elemen interaktif di luar sudut pandang yang nyaman.
+
+#### Pola iOS 18
+Liquid Glass untuk navigation bar. Tata letak adaptif dari iPhone ke iPad ke Mac. SF Symbols 6 dengan rendering variabel.
+
+### Material Design 3 (Google)
+
+#### Warna Dinamis (M3)
+Hasilkan sistem warna penuh dari satu warna seed menggunakan `@material/material-color-utilities`.
+
+#### Komponen M3 Utama
+- **Kartu**: Elevated (bayangan), Filled (varian permukaan), Outlined (batas).
+- **Chip**: Filter, Input, Saran, Bantuan — masing-masing dengan tujuan berbeda.
+- **Navigasi**: Bottom bar (≤5 item), Rail (tablet), Drawer (desktop).
+
+### Protokol Audit HIG
+Saat meninjau desain, periksa: Hierarki (apakah aksi utama langsung terlihat jelas?), Harmoni (apakah spacing konsisten?), Konsistensi (apakah elemen interaktif mengikuti konvensi platform?), Aksesibilitas (lulus WCAG 2.2? Target sentuh ≥ 24×24px?), dan Kesesuaian Platform (apakah terasa native untuk platform target?).

package/skills/js-backend-expert/SKILL.md

@@ -0,0 +1,192 @@
+---
+name: js-backend-expert
+description: "Expert-level skill for Node.js 22+, Bun 1.2+, and Deno 2.x backend development. Covers Express 5, Fastify 5, Hono, NestJS, Prisma 6, Drizzle ORM, WebSockets, and microservices in English and Indonesian."
+author: "Roedy Rustam"
+---
+
+# JS Backend Expert (Node.js 24 / Bun 1.2 / Deno 2.x Edition)
+
+[English](#english) | [Bahasa Indonesia](#bahasa-indonesia)
+
+---
+
+<a name="english"></a>
+## English
+
+### Description
+Production-grade guidance for building fast, scalable, and resilient JavaScript/TypeScript backend APIs, microservices, and serverless functions across **Node.js 24 (LTS)**, **Bun 1.2+**, and **Deno 2.x**. Covers high-throughput frameworks (Fastify 5, Hono, Express 5, NestJS), type-safe ORMs (Drizzle, Prisma 6), **Hono RPC** for type-safe full-stack communication, Edge Runtime patterns, WebSockets, BullMQ background jobs, and graceful shutdown handling.
+
+### Trigger Conditions
+- Bootstrapping or refactoring a Node.js, Bun, or Deno backend application or microservice.
+- Writing RESTful, GraphQL, WebSocket, or SSE (Server-Sent Events) API endpoints.
+- Developing web servers using **Fastify 5**, **Hono**, **Express 5**, or **NestJS**.
+- Building type-safe full-stack apps with **Hono RPC** or **tRPC**.
+- Deploying backend logic to Edge Runtimes (Cloudflare Workers, Vercel Edge).
+- Interacting with databases using **Drizzle ORM**, **Prisma 6**, or **Kysely**.
+- Setting up background job processing with **BullMQ** and **Redis**.
+- Implementing rate limiting, CORS, Content Security Policy (CSP), and JWT/Session authentication.
+- Writing backend tests using **Vitest**, **Supertest**, or Node's native `node:test` runner.
+
+### Runtime Matrix (Node.js 24 vs Bun 1.2 vs Deno 2.x)
+
+| Feature / Runtime | Node.js 24 (LTS) | Bun 1.2+ | Deno 2.x |
+|---|---|---|---|
+| Module Standard | Native ESM / CJS | Native ESM / CJS | Native ESM |
+| `.env` Loading | Native `--env-file` | Native | Native |
+| TypeScript Execution | Native `--experimental-strip-types` / `tsx` | Native (Zero-config) | Native (Zero-config) |
+| HTTP Server | `node:http` / `Fastify` | `Bun.serve()` / `Hono` | `Deno.serve()` / `Hono` |
+| Native WebSockets | Built-in (`WebSocket`) | Built-in (`Bun.serve`) | Built-in (`Deno.upgradeWebSocket`) |
+| Package Manager | npm / pnpm | bun (built-in) | npm / jsr |
+| Test Runner | `node:test` / Vitest | `bun test` | `deno test` |
+| Edge Deploy | Vercel Serverless | Railway / Fly.io | Deno Deploy |
+
+### Framework Guidance
+
+#### 1. Fastify 5 (High-Throughput & Schema Validation)
+Use Fastify for performance-critical REST APIs. Always validate input using **TypeBox** or **Zod**:
+```typescript
+import Fastify from 'fastify';
+import { z } from 'zod';
+
+const app = Fastify({ logger: true });
+
+app.post('/api/users', async (request, reply) => {
+  const bodySchema = z.object({
+    email: z.string().email(),
+    name: z.string().min(2),
+  });
+  const data = bodySchema.parse(request.body);
+  return reply.status(201).send({ status: 'created', user: data });
+});
+```
+
+#### 2. Hono (Multi-Runtime & Hono RPC)
+Use Hono for cross-runtime backends. The killer feature in 2026 is **Hono RPC** — end-to-end type-safe API calls without code generation:
+```typescript
+// server.ts
+import { Hono } from 'hono';
+import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
+
+const app = new Hono()
+  .get('/health', (c) => c.json({ status: 'ok' }))
+  .post(
+    '/users',
+    zValidator('json', z.object({ name: z.string(), email: z.string().email() })),
+    async (c) => {
+      const body = c.req.valid('json');
+      const user = await db.user.create({ data: body });
+      return c.json(user, 201);
+    }
+  );
+
+export type AppType = typeof app;
+export default app;
+
+// client.ts — fully type-safe, no codegen needed
+import { hc } from 'hono/client';
+import type { AppType } from './server';
+
+const client = hc<AppType>('http://localhost:3000');
+const res = await client.users.$post({ json: { name: 'Alice', email: 'alice@example.com' } });
+const user = await res.json(); // Fully typed!
+```
+
+#### 3. Express 5
+Express 5 natively catches rejected promises in async route handlers — eliminating the need for `express-async-errors`. It's ideal for teams already familiar with Express.
+
+#### 4. Edge Runtime (Cloudflare Workers / Vercel Edge)
+For ultra-low latency at the edge, use **Hono** (runs natively on all edge platforms):
+```typescript
+// Cloudflare Worker
+export default {
+  async fetch(request: Request, env: Env): Promise<Response> {
+    return app.fetch(request, env);
+  }
+};
+```
+Edge Runtime restrictions: No Node.js built-ins (`fs`, `path`), limited memory, no long-running processes. Use `fetch`, Web Crypto API, and Cloudflare KV/D1/R2.
+
+---
+
+### Type-Safe Data Layer (Drizzle ORM & Prisma 6)
+- **Drizzle ORM**: Prefer for zero-overhead, SQL-like TypeScript query building in serverless/edge applications.
+- **Prisma 6**: Prefer for complex relational schema modeling, auto-generated TypeScript client, and rich `prisma studio` tooling.
+- **Connection Pooling**: Always use connection poolers (PgBouncer, Supavisor, Neon Hyperdrive) when deploying serverless handlers.
+
+### Background Jobs (BullMQ + Redis)
+```typescript
+import { Queue, Worker } from 'bullmq';
+import { Redis } from 'ioredis';
+
+const connection = new Redis({ maxRetriesPerRequest: null });
+const emailQueue = new Queue('email', { connection });
+
+// Enqueue
+await emailQueue.add('welcome-email', { userId: '123' }, { delay: 1000 });
+
+// Worker
+const worker = new Worker('email', async (job) => {
+  await sendWelcomeEmail(job.data.userId);
+}, { connection, concurrency: 5 });
+```
+
+### Graceful Shutdown & Resilience
+Never terminate the process abruptly. Clean up database pools, HTTP listeners, and Redis queues:
+```typescript
+const shutdown = async (signal: string) => {
+  console.log(`Received ${signal}. Shutting down gracefully...`);
+  await server.close();
+  await dbPool.end();
+  await worker.close();
+  process.exit(0);
+};
+
+process.on('SIGTERM', () => shutdown('SIGTERM'));
+process.on('SIGINT', () => shutdown('SIGINT'));
+```
+
+---
+
+<a name="bahasa-indonesia"></a>
+## Bahasa Indonesia
+
+### Deskripsi
+Panduan tingkat produksi untuk membangun API backend JavaScript/TypeScript yang cepat, skalabel, dan tangguh di lingkungan **Node.js 24 (LTS)**, **Bun 1.2+**, dan **Deno 2.x**. Mencakup framework berkinerja tinggi (Fastify 5, Hono, Express 5, NestJS), ORM type-safe (Drizzle, Prisma 6), **Hono RPC** untuk komunikasi full-stack type-safe, pola Edge Runtime, WebSocket, background jobs (BullMQ), dan penanganan *graceful shutdown*.
+
+### Kondisi Pemicu
+- Merancang atau merefaktor aplikasi backend Node.js, Bun, atau Deno.
+- Menulis endpoint RESTful, GraphQL, WebSocket, atau SSE.
+- Membangun web server dengan Fastify 5, Hono, Express 5, atau NestJS.
+- Membangun aplikasi full-stack type-safe dengan **Hono RPC** atau tRPC.
+- Men-deploy logika backend ke Edge Runtime (Cloudflare Workers, Vercel Edge).
+- Berinteraksi dengan database menggunakan Drizzle ORM, Prisma 6, atau Kysely.
+- Mengatur background job dengan BullMQ dan Redis.
+
+### Matriks Runtime
+Node.js 24 sebagai LTS terbaru, Bun 1.2+ untuk performa maksimal dan zero-config TypeScript, Deno 2.x untuk keamanan bawaan dan kompatibilitas npm.
+
+### Panduan Framework
+
+#### 1. Fastify 5 — Kinerja Tinggi & Validasi Skema
+Gunakan untuk REST API dengan throughput tinggi. Selalu validasi input menggunakan TypeBox atau Zod.
+
+#### 2. Hono & Hono RPC — Multi-Runtime & Type-Safe Full-Stack
+Hono berjalan di Node.js, Bun, Cloudflare Workers, dan Deno. **Hono RPC** adalah fitur unggulan 2026 — panggilan API end-to-end yang fully type-safe tanpa code generation. Klien mendapatkan tipe yang tepat dari definisi server secara otomatis.
+
+#### 3. Express 5
+Express 5 otomatis menangkap rejected promises di async route handler tanpa butuh library tambahan.
+
+#### 4. Edge Runtime (Cloudflare Workers / Vercel Edge)
+Gunakan Hono untuk latensi ultra-rendah di edge. Batasan edge: tanpa built-in Node.js (`fs`, `path`), memori terbatas, tanpa proses long-running. Gunakan `fetch`, Web Crypto API, dan Cloudflare KV/D1/R2.
+
+### Lapisan Data Type-Safe
+- **Drizzle ORM**: Ideal untuk serverless/edge dengan query bergaya SQL dan zero overhead.
+- **Prisma 6**: Ideal untuk pemodelan skema relasional kompleks dan tooling prisma studio yang kaya.
+- **Connection Pooling**: Wajib di lingkungan serverless — gunakan PgBouncer, Supavisor, atau Neon Hyperdrive.
+
+### Background Jobs (BullMQ + Redis)
+Gunakan BullMQ dengan Redis untuk pemrosesan tugas latar belakang yang andal dengan retry otomatis, delay, dan konkurensi yang dapat dikonfigurasi.
+
+### Graceful Shutdown
+Jangan hentikan proses secara mendadak. Bersihkan connection pool, HTTP server, dan worker queue sebelum keluar.