@nmvuong92/fluxe 0.5.0 → 0.7.0

package/README.md

@@ -4,12 +4,12 @@
 [![npm](https://img.shields.io/npm/v/@nmvuong92/fluxe.svg)](https://www.npmjs.com/package/@nmvuong92/fluxe)
 [![license](https://img.shields.io/badge/license-Apache--2.0-blue.svg)](LICENSE)
 
-Khung fullstack **polyglot** dựa trên triết lý **RCA — Resolved Cell Architecture**:
-*logic chỉ phụ thuộc HỢP ĐỒNG; mọi quyết định vận hành (ngôn ngữ, render, transport,
-backend, scale) là **kết quả được GIẢI** bởi engine, không viết tay.*
+Khung fullstack tối giản — **một runtime TypeScript** (chạy trên `node:http` zero-dep) — dựa
+trên triết lý **RCA — Resolved Cell Architecture**: *logic chỉ phụ thuộc HỢP ĐỒNG; mọi quyết định
+vận hành (render, backend data) là **kết quả được GIẢI** bởi engine, không viết tay.*
 
-> Đổi backend từ TS → Go → Rust, đổi render static ↔ island, gộp nhiều backend trong một
-> app per-cell — tất cả chỉ sửa `app/profiles.ts`, **cell & frontend không đổi một dòng**.
+> Đổi backend data `memory ↔ sqlite ↔ postgres`, đổi render `static ↔ island`, gộp nhiều backend
+> trong một app per-cell — tất cả chỉ sửa `app/profiles.ts`, **cell & frontend không đổi một dòng**.
 
 ## Cài & dùng (npm)
 
@@ -34,7 +34,7 @@ import { rpc } from "@nmvuong92/fluxe/client";
 
 ```bash
 npm install
-npm run fx -- build        # resolve + prerender + bundle (1 schema → TS/Go/Rust qua fx gen)
+npm run fx -- build        # resolve + prerender + bundle (1 schema → types TS qua fx gen)
 npm run fx -- dev          # http://localhost:5180
 npm run test:all           # typecheck + 107 unit + 28 integration — TẤT CẢ XANH
 ```
@@ -47,10 +47,9 @@ npm run test:all           # typecheck + 107 unit + 28 integration — TẤT C
 app/        ← DEV sở hữu (sửa thoải mái) — Contract Plane
   cells/        trang/feature (route + loader + view + action/head/layout/guard)
   layouts/      layout dùng chung (nested)
-  profiles.ts   CHỌN backend per môi trường + per-cell (memory/go/rust)
-  contract.ts   schema → codegen TS/Go/Rust
+  profiles.ts   CHỌN backend data per môi trường + per-cell (memory/sqlite/postgres)
+  contract.ts   schema → codegen types TS
   env.ts        env có kiểu, validate fail-fast lúc boot
-  native/       service Go/Rust CỦA DEV (backend/host/hot/actor)
 
 src/        ← ENGINE (không đụng) — Resolution Plane
   core/         resolver · router · errors · auth · validate · codegen · layouts ·
@@ -63,28 +62,34 @@ folder. Engine không bao giờ import ngược vào `app/`.
 
 ## Tính năng (tất cả TDD + chạy thật)
 
-- **Render** — static (0 JS) · island hydrate · SPA nav (Inertia) · static-prerender (Go phục vụ thẳng) · API mode `?json=1`
+- **Render** — static (0 JS) · island hydrate · SPA nav (Inertia) · static-prerender · API mode `?json=1`
 - **Routing** — động `[param]` → `ctx.input` · **nested layouts** · SEO (head/canonical/OG/JSON-LD per cell, `/sitemap.xml`, `/robots.txt`)
 - **Bảo mật (đầy đủ)** — input validation (Zod) · auth password **scrypt** · **RBAC** · **CSRF** double-submit · **rate-limit** token-bucket · error handling không-leak + structured
-- **Data** — backend polyglot per-cell · DB **SQLite thật** + adapter **Postgres** · **codegen contract** 1 schema → TS/Go/Rust
+- **Data** — backend TS per-cell (`memory`/`sqlite`/`postgres`) · DB **SQLite thật** (`node:sqlite`) + **Postgres** (inject client `pg`) · **codegen contract** 1 schema → types TS
 - **Mutations DX** — `RpcError` có cấu trúc · `mutate()` optimistic + rollback · lỗi validation field-level
-- **Realtime (Trục 4g)** — **SSE channel** + pub/sub broker · live-update on action · **presence** (multi-tab) · **actor-Go** (BEAM-style: room=goroutine, supervisor restart)
+- **Realtime (Trục 4g)** — **SSE channel** + pub/sub broker · live-update on action · **presence** (multi-tab)
 - **Async** — **job queue bền** (SQLite, retry → dead-letter)
 - **Observability** — request log + dashboard `/_fluxe` (RCA Resolution + Recent requests)
 - **Config** — env có kiểu, fail-fast lúc boot
 - **DX** — `fx` CLI · mock `Backend` test cực dễ · typecheck gate
 
-## Polyglot 4 tầng (Go/Rust thật, đã chạy)
+## Backend data (driver TS in-process)
 
-| Tầng | Ngôn ngữ | Demo |
-|------|----------|------|
-| **Backend** (Todo CRUD) | Go · Rust | `./run-native.sh` |
-| **Host/edge** (proxy + static) | Go | `./run-host.sh` |
-| **Hot compute** (search) | Rust | `./run-hot.sh` |
-| **Actor/realtime** (room+supervisor) | Go | `./run-actor.sh` |
+Backend chỉ là **driver data TypeScript in-process** — chọn qua `app/profiles.ts`, cell không đổi:
 
-Engine viết bằng: **TS** (Resolver + SSR/cell) · **Go** (host/actor) · **Rust** (hot compute) —
-mỗi tầng đúng ngôn ngữ tối ưu, đúng §6d của [idea.md](idea.md).
+| Driver | Ghi chú |
+|--------|---------|
+| `memory` | in-process, mặc định dev |
+| `sqlite` | `node:sqlite` built-in, 0 dep, persist ra file (engine tự dựng) |
+| `postgres` | production — **bạn tự inject client `pg`** (`npm i pg` + `DATABASE_URL`) |
+
+```ts
+export const profiles = {
+  dev:    { name: "dev",    backend: "memory" },
+  sqlite: { name: "sqlite", backend: "sqlite" },
+  mixed:  { name: "mixed",  backend: "memory", cellBackends: { todos: "sqlite" } },
+};
+```
 
 ## Triết lý
 

package/lib/core/broker.js

@@ -1,8 +1,8 @@
 // Copyright (c) 2026 nmvuong92
 // SPDX-License-Identifier: Apache-2.0
 /* Broker pub/sub in-memory — nền của realtime channel (Trục 4g), bản 1-node.
- * Bản distributed: thay bằng NATS/Redis fan-out (cùng interface). Bản stateful:
- * actor-Go (app/native/actor-go). Đây là lõi đơn giản nhất, dependency-free. */
+ * Bản distributed: thay bằng NATS/Redis fan-out (cùng interface). Đây là lõi
+ * đơn giản nhất, dependency-free. */
 export function createBroker() {
     const subs = new Map();
     return {

package/lib/core/cli.js

@@ -22,7 +22,7 @@ export const COMMANDS = {
         shell: () => `tsx scripts/config.ts`,
     },
     gen: {
-        desc: "Codegen contract → types TS/Go/Rust (.fluxe/gen)",
+        desc: "Codegen contract → types TS (.fluxe/gen)",
         shell: () => `tsx scripts/codegen.ts`,
     },
     resolve: {

package/lib/core/client.d.ts

@@ -7,8 +7,6 @@ export declare class RpcError extends Error {
 export declare function parseRpcError(status: number, body: string): RpcError;
 export declare const setChaos: (v: string) => void;
 export declare const getChaos: () => string;
-export declare const setDevBackend: (v: string) => void;
-export declare const getDevBackend: () => string;
 export interface RpcMeta {
     resolution?: string;
     serverMs?: number;

package/lib/core/client.js

@@ -36,13 +36,10 @@ function cookie(name) {
     const m = document.cookie.match(new RegExp("(?:^|; )" + name + "=([^;]*)"));
     return m ? decodeURIComponent(m[1]) : "";
 }
-/* DevTools config (chỉ ảnh hưởng dev): chaos injection + live backend swap. DebugBar set. */
+/* DevTools config (chỉ ảnh hưởng dev): chaos injection. DebugBar set. */
 let _chaos = ""; // vd "delay=600;fail=0.3"
-let _devBackend = ""; // vd "go" | "rust" | "memory"
 export const setChaos = (v) => { _chaos = v; };
 export const getChaos = () => _chaos;
-export const setDevBackend = (v) => { _devBackend = v; };
-export const getDevBackend = () => _devBackend;
 let _lastMeta = {};
 export const lastRpcMeta = () => _lastMeta;
 export async function rpc(cell, action, input) {
@@ -50,8 +47,6 @@ export async function rpc(cell, action, input) {
     const headers = { "content-type": "application/json", "x-csrf-token": cookie("csrf") };
     if (_chaos)
         headers["x-fluxe-chaos"] = _chaos; // #1 chaos
-    if (_devBackend)
-        headers["x-fluxe-backend"] = _devBackend; // #5 live swap
     let res;
     try {
         res = await fetch(`/__action/${cell}/${action}`, { method: "POST", headers, body: JSON.stringify(input) });

package/lib/core/codegen.d.ts

@@ -3,5 +3,3 @@ export interface Schema {
     types: Record<string, Record<string, FieldType>>;
 }
 export declare function genTS(s: Schema): string;
-export declare function genGo(s: Schema, pkg?: string): string;
-export declare function genRust(s: Schema): string;

package/lib/core/codegen.js

@@ -1,11 +1,7 @@
 // Copyright (c) 2026 nmvuong92
 // SPDX-License-Identifier: Apache-2.0
-/* Codegen contract polyglot — MỘT schema → types TS + Go + Rust (chữ ký RCA:
- * type-safe xuyên ngôn ngữ). Thuần (string-in/string-out), dễ test. */
-const pascal = (s) => s.charAt(0).toUpperCase() + s.slice(1);
+/* Codegen contract — MỘT schema → types TS. Thuần (string-in/string-out), dễ test. */
 const TS = { string: "string", bool: "boolean", int: "number" };
-const GO = { string: "string", bool: "bool", int: "int" };
-const RS = { string: "String", bool: "bool", int: "i64" };
 export function genTS(s) {
     return Object.entries(s.types)
         .map(([name, fields]) => `export interface ${name} {\n` +
@@ -13,18 +9,3 @@ export function genTS(s) {
         `\n}`)
         .join("\n\n") + "\n";
 }
-export function genGo(s, pkg = "contract") {
-    return `package ${pkg}\n\n` +
-        Object.entries(s.types)
-            .map(([name, fields]) => `type ${name} struct {\n` +
-            Object.entries(fields).map(([f, t]) => `\t${pascal(f)} ${GO[t]} \`json:"${f}"\``).join("\n") +
-            `\n}`)
-            .join("\n\n") + "\n";
-}
-export function genRust(s) {
-    return Object.entries(s.types)
-        .map(([name, fields]) => `#[derive(Clone, Debug)]\npub struct ${name} {\n` +
-        Object.entries(fields).map(([f, t]) => `    pub ${f}: ${RS[t]},`).join("\n") +
-        `\n}`)
-        .join("\n\n") + "\n";
-}

package/lib/core/config.d.ts

@@ -3,7 +3,7 @@ declare const Schema: z.ZodObject<{
     env: z.ZodEnum<["development", "production", "test"]>;
     secret: z.ZodString;
     port: z.ZodNumber;
-    defaultBackend: z.ZodEnum<["memory", "go", "rust"]>;
+    defaultBackend: z.ZodEnum<["memory", "sqlite", "postgres"]>;
     rateLimit: z.ZodObject<{
         capacity: z.ZodNumber;
         refillPerSec: z.ZodNumber;
@@ -42,7 +42,7 @@ declare const Schema: z.ZodObject<{
     env: "development" | "production" | "test";
     secret: string;
     port: number;
-    defaultBackend: "memory" | "go" | "rust";
+    defaultBackend: "memory" | "sqlite" | "postgres";
     rateLimit: {
         capacity: number;
         refillPerSec: number;
@@ -61,7 +61,7 @@ declare const Schema: z.ZodObject<{
     env: "development" | "production" | "test";
     secret: string;
     port: number;
-    defaultBackend: "memory" | "go" | "rust";
+    defaultBackend: "memory" | "sqlite" | "postgres";
     rateLimit: {
         capacity: number;
         refillPerSec: number;

package/lib/core/config.js

@@ -9,7 +9,7 @@ const Schema = z.object({
     env: z.enum(["development", "production", "test"]),
     secret: z.string().min(8),
     port: z.coerce.number().int().positive(),
-    defaultBackend: z.enum(["memory", "go", "rust"]),
+    defaultBackend: z.enum(["memory", "sqlite", "postgres"]),
     rateLimit: z.object({
         capacity: z.coerce.number().int().positive(),
         refillPerSec: z.coerce.number().positive(),

package/lib/core/engine.d.ts

@@ -1,31 +1,30 @@
 import type { ComponentType } from "react";
-import type { Backend } from "../backends/types";
 import type { HeadMeta } from "./seo";
 import type { Session } from "./auth";
 import type { TFn } from "./i18n";
-export interface Ctx<I> {
+export interface Ctx<I, B = any> {
     input: I;
-    backend: Backend;
+    backend: B;
     session?: Session | null;
     locale?: string;
     t?: TFn;
 }
-export type Loader<I, O> = (ctx: Ctx<I>) => Promise<O>;
-export type Action<I, O> = (ctx: Ctx<I>) => Promise<O>;
+export type Loader<I, O, B = any> = (ctx: Ctx<I, B>) => Promise<O>;
+export type Action<I, O, B = any> = (ctx: Ctx<I, B>) => Promise<O>;
 export type Hydration = "static" | "island";
-export interface CellDef<I, O> {
+export interface CellDef<I, O, B = any> {
     id: string;
     route: string;
     hydration?: Hydration;
-    loader: Loader<I, O>;
+    loader: Loader<I, O, B>;
     view: ComponentType<{
         data: O;
     }>;
-    actions?: Record<string, Action<any, any>>;
+    actions?: Record<string, Action<any, any, B>>;
     head?: (data: O) => HeadMeta;
     layout?: string;
     requireAuth?: boolean;
     requireRole?: string;
     cache?: boolean;
 }
-export declare function defineCell<I, O>(c: CellDef<I, O>): CellDef<I, O>;
+export declare function defineCell<I, O, B = any>(c: CellDef<I, O, B>): CellDef<I, O, B>;

package/lib/core/panel.js

@@ -9,8 +9,6 @@ export function renderResolutionPanel(m, requests = []) {
         <td>${c.render.mode}</td>
         <td>${c.render.shipClientJs ? "✓ JS" : "0 JS"}</td>
         <td><span class="badge ${c.backend.language}">${c.backend.language}</span></td>
-        <td>${c.backend.transport}</td>
-        <td>${c.backend.endpoint ?? "—"}</td>
       </tr>`).join("");
     return `<!doctype html><html lang="vi"><head><meta charset="utf-8"><title>fluxe — RCA Resolution</title>
 <style>
@@ -22,13 +20,13 @@ export function renderResolutionPanel(m, requests = []) {
   th{color:#8a8aa0;font-weight:600;font-size:.78rem;text-transform:uppercase;letter-spacing:.04em}
   code{background:#1a1a2e;padding:.1rem .35rem;border-radius:4px;color:#a0a0ff}
   .badge{display:inline-block;padding:.1rem .55rem;border-radius:99px;font-size:.78rem}
-  .go{background:#00add833;color:#5fd3f0}.rust{background:#dea58433;color:#e8b48f}.memory{background:#7c7cff33;color:#a0a0ff}
+  .memory{background:#7c7cff33;color:#a0a0ff}.sqlite{background:#00add833;color:#5fd3f0}.postgres{background:#dea58433;color:#e8b48f}
 </style></head>
 <body>
   <h1>RCA Resolution</h1>
-  <div class="sub">profile <b>${m.profile}</b> · default backend <b>${m.backend.language}</b> (${m.backend.transport})</div>
+  <div class="sub">profile <b>${m.profile}</b> · default backend <b>${m.backend.language}</b> (in-process)</div>
   <table>
-    <thead><tr><th>cell</th><th>route</th><th>render</th><th>JS</th><th>backend</th><th>transport</th><th>endpoint</th></tr></thead>
+    <thead><tr><th>cell</th><th>route</th><th>render</th><th>JS</th><th>backend</th></tr></thead>
     <tbody>${rows}
     </tbody>
   </table>

package/lib/core/resolver.d.ts

@@ -1,5 +1,5 @@
 export type RenderMode = "static" | "island";
-export type BackendKind = "memory" | "go" | "rust";
+export type BackendKind = "memory" | "sqlite" | "postgres";
 export interface CellDecl {
     id: string;
     route: string;
@@ -8,16 +8,10 @@ export interface CellDecl {
 export interface ResolutionProfile {
     name: string;
     backend: BackendKind;
-    endpoints?: {
-        go?: string;
-        rust?: string;
-    };
     cellBackends?: Record<string, BackendKind>;
 }
 export interface BackendResolution {
     language: BackendKind;
-    transport: "in-process" | "http";
-    endpoint?: string;
 }
 export interface CellResolution {
     id: string;

package/lib/core/resolver.js

@@ -1,17 +1,11 @@
-const ALLOWED = ["memory", "go", "rust"];
-// Giải một BackendKind → BackendResolution (validate endpoint nếu http). Dùng chung
-// cho default app-level lẫn override per-cell.
+const ALLOWED = ["memory", "sqlite", "postgres"];
+// Giải một BackendKind → BackendResolution. Mọi driver TS đều in-process (0 roundtrip).
+// Dùng chung cho default app-level lẫn override per-cell.
 function resolveBackend(kind, profile) {
     if (!ALLOWED.includes(kind)) {
         throw new Error(`profile "${profile.name}": backend không hợp lệ: ${kind}`);
     }
-    if (kind === "memory")
-        return { language: "memory", transport: "in-process" };
-    const endpoint = profile.endpoints?.[kind];
-    if (!endpoint) {
-        throw new Error(`profile "${profile.name}": backend "${kind}" cần endpoints.${kind}`);
-    }
-    return { language: kind, transport: "http", endpoint };
+    return { language: kind };
 }
 export function resolve(cells, profile) {
     const ids = new Set(cells.map((c) => c.id));

package/lib/core/wiring.js

@@ -1,22 +1,24 @@
 import { createMemoryBackend } from "../backends/memory.js";
-import { createHttpBackend } from "../backends/http.js";
+import { createSqliteBackend } from "../backends/sqlite.js";
+// Driver TS in-process, engine dựng được zero-dep. (postgres cần client `pg` → user tự inject,
+// không phải kind auto-resolve.)
 function buildBackend(b) {
     if (b.language === "memory")
         return createMemoryBackend();
-    if (!b.endpoint)
-        throw new Error(`manifest backend "${b.language}" thiếu endpoint`);
-    return createHttpBackend(b.language, b.endpoint);
+    if (b.language === "sqlite")
+        return createSqliteBackend(process.env.FLUXE_SQLITE_PATH ?? ":memory:");
+    throw new Error(`manifest backend "${b.language}" không dựng được tự động (chỉ memory | sqlite)`);
 }
 // Backend app-level (default) — giữ cho code cũ/đơn giản.
 export function backendFromManifest(m) {
     return buildBackend(m.backend);
 }
-// Dựng backend per-cell, DEDUP theo key `language:endpoint` → cells cùng resolution
+// Dựng backend per-cell, DEDUP theo `language` → cells cùng resolution
 // chia sẻ MỘT instance (vd memory dùng chung một store).
 export function backendsFromManifest(m) {
     const cache = new Map();
     const make = (b) => {
-        const key = `${b.language}:${b.endpoint ?? ""}`;
+        const key = b.language;
         let inst = cache.get(key);
         if (!inst) {
             inst = buildBackend(b);

package/lib/index.d.ts

@@ -22,6 +22,6 @@ export { createMemoryStorage } from "./storage/memory.ts";
 export { createLocalStorage } from "./storage/local.ts";
 export { createS3Storage } from "./storage/s3.ts";
 export { createMemoryBackend } from "./backends/memory.ts";
-export { createHttpBackend } from "./backends/http.ts";
+export { createSqliteBackend } from "./backends/sqlite.ts";
 export { createPostgresBackend } from "./backends/postgres.ts";
 export { makeServer } from "./server_factory.ts";

package/lib/index.js

@@ -16,7 +16,7 @@ export * from "./core/seo.js"; // renderHead, renderSitemap, renderRobots, HeadM
 export * from "./core/broker.js"; // pub/sub
 export * from "./core/presence.js"; // ai online theo topic
 export * from "./core/ratelimit.js"; // token-bucket + LRU
-export * from "./core/codegen.js"; // genTS/genGo/genRust
+export * from "./core/codegen.js"; // genTS
 export * from "./core/layouts.js"; // layoutChain, LayoutMeta
 export * from "./core/router.js"; // makeRouter
 export * from "./core/testing.js"; // createTestBackend
@@ -26,6 +26,6 @@ export { createMemoryStorage } from "./storage/memory.js";
 export { createLocalStorage } from "./storage/local.js";
 export { createS3Storage } from "./storage/s3.js"; // adapter tham chiếu (cần @aws-sdk/client-s3)
 export { createMemoryBackend } from "./backends/memory.js";
-export { createHttpBackend } from "./backends/http.js";
-export { createPostgresBackend } from "./backends/postgres.js";
+export { createSqliteBackend } from "./backends/sqlite.js";
+export { createPostgresBackend } from "./backends/postgres.js"; // user tự inject client `pg`
 export { makeServer } from "./server_factory.js";

package/lib/react/DebugBar.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 import { createElement as h, useState, useSyncExternalStore } from "react";
 import { debug } from "./store";
-import { setChaos, getChaos, setDevBackend, getDevBackend } from "../core/client";
+import { setChaos, getChaos } from "../core/client";
 import { reproTest } from "./repro";
 const EMPTY = [];
 const DOT = { pending: "#e3b341", ok: "#3fb950", error: "#f85149" };
@@ -29,9 +29,8 @@ export function DebugBar() {
         }, `⚡ fluxe · ${events.length}${errs ? ` · ${errs}✗` : ""}`));
     }
     const chaosOn = getChaos() !== "";
-    const be = getDevBackend();
-    // #1 Chaos toggle + #5 backend swap
-    const controls = h("div", { style: { display: "flex", gap: 6, alignItems: "center", padding: "6px 10px", background: "#0d1117", borderBottom: "1px solid #21262d", flexWrap: "wrap" } }, h("button", { onClick: () => { setChaos(chaosOn ? "" : CHAOS); force((x) => x + 1); }, style: ctrlBtn(chaosOn), title: CHAOS }, chaosOn ? "🔥 Chaos ON" : "Chaos"), h("span", { style: { color: "#7d8590" } }, "backend:"), ...["", "memory", "go", "rust"].map((v) => h("button", { key: v || "auto", onClick: () => { setDevBackend(v); force((x) => x + 1); }, style: ctrlBtn(be === v) }, v || "auto")));
+    // #1 Chaos toggle
+    const controls = h("div", { style: { display: "flex", gap: 6, alignItems: "center", padding: "6px 10px", background: "#0d1117", borderBottom: "1px solid #21262d", flexWrap: "wrap" } }, h("button", { onClick: () => { setChaos(chaosOn ? "" : CHAOS); force((x) => x + 1); }, style: ctrlBtn(chaosOn), title: CHAOS }, chaosOn ? "🔥 Chaos ON" : "Chaos"));
     const rows = events.length === 0
         ? [h("div", { key: "e", style: { color: "#7d8590", padding: 8 } }, "Tương tác đi — query/mutation sẽ hiện ở đây.")]
         : events.map((e) => h("div", { key: e.id, onClick: () => { setSel(sel === e.id ? null : e.id); setCopied(false); },

package/lib/server_factory.d.ts

@@ -15,5 +15,6 @@ export declare function makeServer(manifest: ResolutionManifest, cells: CellDef<
     i18n?: I18n;
     storage?: Storage;
     config?: FluxeConfig;
+    backend?: unknown;
 }): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
 export {};

package/lib/server_factory.js

@@ -25,22 +25,6 @@ import { resolveLocale, makeT } from "./core/i18n.js";
 import { parseMultipart, boundaryFromContentType } from "./core/multipart.js";
 import { makeKey } from "./storage/types.js";
 import { loadConfig } from "./core/config.js";
-import { createMemoryBackend } from "./backends/memory.js";
-import { createHttpBackend } from "./backends/http.js";
-// Build backend theo ngôn ngữ (cho live swap trong devtools).
-// Map ngôn ngữ → service HTTP demo (cùng hợp đồng list/add/toggle). Override bằng <LANG>_URL.
-const DEV_BACKENDS = {
-    go: "http://127.0.0.1:8081",
-    rust: "http://127.0.0.1:8082",
-    python: "http://127.0.0.1:8083",
-    hono: "http://127.0.0.1:8084",
-    dotnet: "http://127.0.0.1:8085",
-    java: "http://127.0.0.1:8086",
-};
-function devBackend(lang) {
-    const url = process.env[`${lang.toUpperCase()}_URL`] ?? DEV_BACKENDS[lang];
-    return url ? createHttpBackend(lang, url) : createMemoryBackend();
-}
 import { randomUUID, randomBytes } from "node:crypto";
 const DEV = process.env.NODE_ENV !== "production";
 const SECRET = process.env.FLUXE_SECRET ?? "dev-secret-change-me";
@@ -114,9 +98,11 @@ export function makeServer(manifest, cells, layouts = {}, opts = {}) {
     // Cells được TIÊM từ app (DI) — engine không import ngược vào app/. Thêm trang = sửa app/app.ts.
     const matchRoute = makeRouter(cells);
     const byId = new Map(cells.map((c) => [c.id, c]));
-    // Backend GIẢI per-cell từ manifest (Resolution Plane) — cell/frontend giữ nguyên.
-    const backends = backendsFromManifest(manifest);
-    const backendFor = (id) => backends.byCell.get(id) ?? backends.default;
+    // Backend USER-OWNED (app/backend.ts) inject qua opts.backend → dùng cho mọi cell.
+    // Nếu app không truyền → fallback driver built-in giải từ manifest (memory/sqlite) cho quick-start.
+    const userBackend = opts.backend;
+    const backends = userBackend === undefined ? backendsFromManifest(manifest) : null;
+    const backendFor = (id) => userBackend ?? backends.byCell.get(id) ?? backends.default;
     // Resolved Container: service realtime đăng ký LƯỜI — chỉ tạo khi thật sự dùng (SSE/action).
     // App không realtime → broker/presence KHÔNG bao giờ bootstrap. resolved() ở /_fluxe/stats.
     const container = createContainer();
@@ -286,15 +272,10 @@ export function makeServer(manifest, cells, layouts = {}, opts = {}) {
                     return res.end("no action");
                 }
                 const t0 = Date.now();
-                // DevTools (DEV): #5 live backend swap + #3 resolution.
-                let backend = backendFor(cellId);
+                // DevTools (DEV): #3 resolution (backend TS in-process do manifest giải).
+                const backend = backendFor(cellId);
                 const r = manifest.cells[cellId]?.backend;
-                let resolution = r ? `${r.language}/${r.transport}` : "memory/in-process";
-                if (DEV && req.headers["x-fluxe-backend"]) {
-                    const lang = String(req.headers["x-fluxe-backend"]);
-                    backend = devBackend(lang);
-                    resolution = `${lang}/${lang === "memory" ? "in-process" : "http"} (swap)`;
-                }
+                const resolution = r ? `${r.language}/in-process` : "memory/in-process";
                 // #1 Chaos (DEV): inject delay + lỗi giả lập để test UX.
                 if (DEV && req.headers["x-fluxe-chaos"]) {
                     const c = parseChaos(String(req.headers["x-fluxe-chaos"]));

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nmvuong92/fluxe",
-  "version": "0.5.0",
-  "description": "fluxe — khung fullstack tối giản polyglot (RCA: Resolved Cell Architecture).",
+  "version": "0.7.0",
+  "description": "fluxe — khung fullstack tối giản, một runtime TS (RCA: Resolved Cell Architecture).",
   "license": "Apache-2.0",
   "author": "nmvuong92",
   "type": "module",

package/lib/backends/http.d.ts

@@ -1,2 +0,0 @@
-import type { Backend } from "./types";
-export declare function createHttpBackend(name: string, baseUrl: string): Backend;

package/lib/backends/http.js

@@ -1,32 +0,0 @@
-/* Backend #3/#4: gọi một service THẬT qua HTTP (Go hoặc Rust).
- * Cùng interface Backend → cell + frontend KHÔNG đổi một dòng.
- * Service chỉ cần tôn trọng "hợp đồng" 3 endpoint:
- *   GET  /todos                 → Todo[]
- *   POST /todos {title}         → Todo
- *   POST /todos/{id}/toggle     → Todo[]
- */
-export function createHttpBackend(name, baseUrl) {
-    const base = baseUrl.replace(/\/$/, "");
-    async function j(path, init) {
-        const r = await fetch(base + path, init);
-        if (!r.ok)
-            throw new Error(`${name} backend ${path} → HTTP ${r.status}`);
-        return (await r.json());
-    }
-    return {
-        name,
-        listTodos() {
-            return j("/todos");
-        },
-        addTodo(title) {
-            return j("/todos", {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                body: JSON.stringify({ title }),
-            });
-        },
-        toggleTodo(id) {
-            return j(`/todos/${encodeURIComponent(id)}/toggle`, { method: "POST" });
-        },
-    };
-}

package/lib/hot/search.d.ts

@@ -1,9 +0,0 @@
-export interface SearchHit {
-    item: string;
-    score: number;
-}
-export interface SearchService {
-    name: string;
-    search(items: string[], query: string): Promise<SearchHit[]>;
-}
-export declare function createRustSearch(baseUrl: string): SearchService;

package/lib/hot/search.js

@@ -1,16 +0,0 @@
-export function createRustSearch(baseUrl) {
-    const base = baseUrl.replace(/\/$/, "");
-    return {
-        name: "rust-hot",
-        async search(items, query) {
-            const r = await fetch(`${base}/search?q=${encodeURIComponent(query)}`, {
-                method: "POST",
-                headers: { "content-type": "text/plain" },
-                body: items.join("\n"),
-            });
-            if (!r.ok)
-                throw new Error(`hot search → HTTP ${r.status}`);
-            return (await r.json());
-        },
-    };
-}