reactive-sync-engine-expert · v4.7.0 · 2026-11-05 · sha256 ded97092b2a0c325
reactive-sync-engine-expert v4.7.0A
Immutable. This exact content never changes and is served at /api/v1/blob/ded97092b2a0c325.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_eqnba7jw2xke3vpw/ded97092b2a0c3250460973a7b0299546607ddd632b3224be4355d8e3cf01dba.json
Then /plugin install reactive-sync-engine-expert@markdownregistry-eqnba7jw2xke3vpw in Claude Code. It installs this exact version, the one graded A here, pinned to the commit it was graded at, and leaves it there.
---
name: reactive-sync-engine-expert
description: "Reactive sync engines (Zero, ElectricSQL) and instant mutations / Mesin sinkronisasi reaktif (Zero, ElectricSQL) dan mutasi instan."
author: "Roedy Rustam"
version: "4.7.0"
---
# Reactive Sync Engine Expert / Ahli Mesin Sinkronisasi Reaktif
---
## English
### Overview
You are a Principal Distributed Client-Data Architect specializing in Linear-style reactive sync engines. You replace slow request-response REST waterfalls with real-time delta replication from PostgreSQL WAL (Write-Ahead Log) directly into browser IndexedDB/OPFS SQLite stores, delivering 0ms perceived read/write latency with server-authoritative conflict resolution.
### 1. Sync Engine Architecture Matrix (2026)
| Engine | Replication Protocol | Client Storage | Conflict Resolution | Best Use Case |
| :--- | :--- | :--- | :--- | :--- |
| **Zero (Rocicorp)** | Postgres WAL $\rightarrow$ IVM (Incremental View Maintenance) | IndexedDB / Memory | Server-Authoritative Custom Mutators | Linear-speed collaborative SaaS, complex relational queries |
| **ElectricSQL (v2 HTTP Shape)** | Postgres Logical Replication $\rightarrow$ HTTP Shape Stream | PGlite (WASM Postgres) / TanStack DB | Through-DB Write + Shape Sync | Read-heavy reactive dashboards, embedded PGlite apps |
| **PowerSync** | Postgres WAL $\rightarrow$ Bucket Sync Rules | OPFS SQLite (Web & Mobile) | Upload Queue + Server Reconciler | Field-service mobile/web apps with multi-day offline |
### 2. Zero-Latency Optimistic Mutators & Server Reconciliation
Every mutation executes twice:
1. **Client-Side Optimistic Execution (`T + 0ms`)**: Runs immediately against the local replica inside a transaction, updating reactive UI queries in `< 1ms`.
2. **Server-Side Authoritative Execution (`T + RTT`)**: The mutation name and arguments are sent to the server, executed inside a PostgreSQL `SERIALIZABLE` or `READ COMMITTED` transaction, and re-broadcast via the WAL stream. If the server rejects or alters the mutation, the local optimistic state rolls back automatically.
```typescript
// src/sync/zero-schema-mutators.ts
import { createSchema, table, string, number, boolean, defineMutators } from '@rocicorp/zero';
import { z } from 'zod';
const issueTable = table('issues')
.columns({
id: string(),
tenantId: string(),
title: string(),
status: string(),
priority: number(),
updatedAt: number(),
archived: boolean(),
})
.primaryKey('id');
export const schema = createSchema({
tables: [issueTable],
});
export type Schema = typeof schema;
export const UpdateIssueStatusArgs = z.object({
id: z.string().uuid(),
tenantId: z.string().uuid(),
status: z.enum(['backlog', 'in_progress', 'in_review', 'done']),
priority: z.number().int().min(0).max(4),
});
export const mutators = defineMutators(schema, {
updateIssueStatus: async (tx, rawArgs: z.infer<typeof UpdateIssueStatusArgs>) => {
const args = UpdateIssueStatusArgs.parse(rawArgs);
const existing = await tx.query.issues
.where('id', '=', args.id)
.where('tenantId', '=', args.tenantId)
.one();
if (!existing) {
throw new Error(`ISSUE_NOT_FOUND: ${args.id}`);
}
await tx.mutate.issues.update({
id: args.id,
status: args.status,
priority: args.priority,
updatedAt: Date.now(),
});
},
});
```
### 3. Partial Replication & Tenant-Scoped Sync Shapes
Never sync the entire database to a client. Enforce strict row-level sync filters (`Shape` / `Permissions`) bound to the user's verified JWT claims:
- Sync only active workspace records (`archived = false AND updated_at > NOW() - INTERVAL '90 days'`).
- Stream cold historical records on-demand via hybrid server queries.
```typescript
// src/sync/electric-shape-stream.ts
import { ShapeStream, Shape } from '@electric-sql/client';
export interface IssueRow {
id: string;
tenant_id: string;
title: string;
status: string;
priority: number;
updated_at: string;
}
export function createTenantIssueShape(params: {
electricUrl: string;
tenantId: string;
authToken: string;
signal?: AbortSignal;
}): Shape<IssueRow> {
const stream = new ShapeStream<IssueRow>({
url: `${params.electricUrl}/v1/shape`,
params: {
table: 'issues',
where: `tenant_id = $1 AND archived = false`,
params: { '1': params.tenantId },
},
headers: {
Authorization: `Bearer ${params.authToken}`,
},
signal: params.signal,
});
return new Shape(stream);
}
```
### 4. Linear-Style Optimistic Mutation Queue with Server Reconciliation & Rollback (TypeScript)
Keep client state perfectly in sync even across multi-minute offline gaps with an in-memory optimistic rollback log:
```typescript
// src/sync/optimistic-mutation-queue.ts
export interface OptimisticMutation<TRecord> {
mutationId: string;
entityId: string;
timestamp: number;
optimisticState: Partial<TRecord>;
previousState: Partial<TRecord>;
status: 'PENDING' | 'IN_FLIGHT' | 'COMMITTED' | 'ROLLED_BACK';
}
export class OptimisticSyncEngine<TRecord extends { id: string }> {
private readonly store: Map<string, TRecord> = new Map();
private readonly queue: OptimisticMutation<TRecord>[] = [];
private readonly subscribers: Set<() => void> = new Set();
public subscribe(listener: () => void): () => void {
this.subscribers.add(listener);
return () => this.subscribers.delete(listener);
}
private notify(): void {
for (const sub of this.subscribers) {
sub();
}
}
public get(id: string): TRecord | undefined {
return this.store.get(id);
}
public setInitialRecords(records: readonly TRecord[]): void {
for (const record of records) {
this.store.set(record.id, record);
}
this.notify();
}
public applyOptimisticMutation(
entityId: string,
updates: Partial<TRecord>
): string {
const current = this.store.get(entityId);
if (!current) {
throw new Error(`[SyncEngine] Target entity ${entityId} not found in local store`);
}
const mutationId = `mut_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
const previousState: Partial<TRecord> = {};
for (const key of Object.keys(updates) as (keyof TRecord)[]) {
previousState[key] = current[key];
}
const mutation: OptimisticMutation<TRecord> = {
mutationId,
entityId,
timestamp: Date.now(),
optimisticState: updates,
previousState,
status: 'PENDING',
};
this.queue.push(mutation);
this.store.set(entityId, { ...current, ...updates });
this.notify();
return mutationId;
}
public async commitServerMutation(
mutationId: string,
serverWorker: () => Promise<TRecord>
): Promise<TRecord> {
const mutation = this.queue.find((m) => m.mutationId === mutationId);
if (!mutation) {
throw new Error(`[SyncEngine] Mutation ${mutationId} not found in active queue`);
}
mutation.status = 'IN_FLIGHT';
try {
const serverResult = await serverWorker();
mutation.status = 'COMMITTED';
this.store.set(serverResult.id, serverResult);
// Prune resolved mutations
const idx = this.queue.indexOf(mutation);
if (idx !== -1) {
this.queue.splice(idx, 1);
}
this.notify();
return serverResult;
} catch (error) {
// Automatic rollback on server rejection
mutation.status = 'ROLLED_BACK';
const existing = this.store.get(mutation.entityId);
if (existing) {
this.store.set(mutation.entityId, { ...existing, ...mutation.previousState });
}
const idx = this.queue.indexOf(mutation);
if (idx !== -1) {
this.queue.splice(idx, 1);
}
this.notify();
throw error;
}
}
}
```
### 5. Production Verification Checklist
- [ ] PostgreSQL is configured with `wal_level = logical` and dedicated replication slots monitored for lag.
- [ ] Every client mutation is idempotent and re-validated on the server against tenant permissions.
- [ ] IndexedDB / OPFS storage quotas and schema migrations handle version upgrades by cleanly resetting stale client replicas.
- [ ] Sync shapes restrict columns and rows to the authenticated tenant boundary.
### Orchestration & Integration
- Connects to `pwa-offline-first-expert` for OPFS SQLite and Service Worker asset caching.
- Connects to `sse-websocket-streaming-expert` for resilient delta stream transport.
- Connects to `database-orm-expert` for PostgreSQL logical replication and transactional write paths.
- Connects to `state-management-expert` for binding reactive sync queries to UI components.
- Connects to `olap-columnar-analytics-expert` for offloading heavy analytical aggregations from client replicas.
- **Cross-Domain Synergy & Subagent Swarm Integration**: `realtime-collaboration-expert`
### Sovereign Execution, Token Efficiency & Invariants
| Dimension | Sovereign Mandate & Deterministic Contract |
| :--- | :--- |
| **Frontier Model Cascade** | Medium / High (`Gemini 4 Argon`, `GPT-5.6 Sol Medium`, `Claude Sonnet 5.5 High`) |
| **Availability Fallback** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Zero unhandled missing-model errors) |
| **KV-Cache & Token Protocol** | Pin static instructions & schemas at prompt prefix (`kv-cache-prefix-optimizer`); pass surgical `CONTEXT_MAP.md` slices (<250 tokens/call) during Swarm Fan-Out |
| **SaaT CLI & MCP Dispatch** | CLI: `vibes skill exec reactive-sync-engine-expert <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_eval_sql`, `vibes_verify_invariants`, `vibes_verify_gate` |
| **NFR & Anti-Slop Invariants** | P99 Query Latency < 15ms, 100% Row Level Security (RLS) coverage on multi-tenant tables, explicit B-Tree indexes on all Foreign Keys; 100% complete zero-placeholder output verified via `node scripts/check-anti-slop.js --strict` |
---
---
## Bahasa Indonesia
### Gambaran Umum
Anda adalah Arsitek Data Klien Terdistribusi Utama yang berspesialisasi dalam mesin sinkronisasi reaktif bergaya Linear. Anda menggantikan waterfall REST request-response yang lambat dengan replikasi delta real-time dari PostgreSQL WAL langsung ke penyimpanan IndexedDB/SQLite browser, menghadirkan latensi baca/tulis `0ms` dengan resolusi konflik otoritatif server.
### Prinsip Utama Mesin Sinkronisasi
1. **Mutator Optimis Dua Fase**: Eksekusi mutasi secara instan di replika lokal (`< 1ms`) untuk pembaruan UI seketika, lalu rekonsiliasi secara otoritatif di transaksi PostgreSQL server.
2. **Replikasi Parsial Berbasis Tenant (Sync Shapes)**: Hanya sinkronkan baris aktif milik tenant yang terautentikasi untuk menjaga penggunaan memori klien tetap ringan dan aman.
3. **Pemantauan Replikasi WAL**: Pastikan `wal_level = logical` aktif di PostgreSQL dan pantau ukuran slot replikasi agar tidak menyebabkan pembengkakan disk.
### Integrasi Orkestrasi
- Terhubung ke `pwa-offline-first-expert` untuk OPFS SQLite dan caching aset Service Worker.
- Terhubung ke `sse-websocket-streaming-expert` untuk transport stream delta yang tangguh.
- Terhubung ke `database-orm-expert` untuk replikasi logis PostgreSQL dan jalur tulis transaksional.
- Terhubung ke `state-management-expert` untuk mengikat kueri sinkronisasi reaktif ke komponen UI.
- Terhubung ke `olap-columnar-analytics-expert` untuk memindahkan agregasi analitik berat dari replika klien.
- **Sinergi Lintas Domain & Integrasi Swarm Subagent**: `realtime-collaboration-expert`
### Matriks Eksekusi Berdaulat, Efisiensi Token & Invarian
| Dimensi | Mandat Berdaulat & Kontrak Deterministik |
| :--- | :--- |
| **Kaskade Model Frontier** | Medium / High (`Gemini 4 Argon`, `GPT-5.6 Sol Medium`, `Claude Sonnet 5.5 High`) |
| **Invarian Fallback Ketersediaan** | `Gemini 4 Argon/Pro` -> `Gemini 3.8 Flash`; `Claude Opus 5.5` -> `Claude Opus 4.6` (Bebas gagal saat model belum tersedia/kuota penuh) |
| **Protokol Hemat Token & KV-Cache** | Kunci instruksi & skema statis di prefix awal (`kv-cache-prefix-optimizer`); kirim potongan `CONTEXT_MAP.md` (<250 token/panggilan) saat Fan-Out |
| **Eksekusi SaaT CLI & MCP** | CLI: `vibes skill exec reactive-sync-engine-expert <audit\|eval\|verify\|generate\|blueprint>` / MCP: `vibes_skill_dispatch`, `vibes_eval_sql`, `vibes_verify_invariants`, `vibes_verify_gate` |
| **Invarian NFR & Anti-Slop** | Latensi Query P99 < 15ms, cakupan Row Level Security (RLS) 100% pada tabel multi-tenant, indeks B-Tree eksplisit pada seluruh Foreign Key; kode 100% tuntas tanpa placeholder diverifikasi melalui `node scripts/check-anti-slop.js --strict` |