weifuwu 0.32.0 → 0.33.0

package/dist/index.js

@@ -618,21 +618,21 @@ var Router = class _Router {
   }
   // ── Private: Mount ─────────────────────────────────────────
   _mountRouter(prefix, sub, extraMws = []) {
-    const base = prefix === "/" ? "" : prefix.replace(/\/$/, "");
+    const base2 = prefix === "/" ? "" : prefix.replace(/\/$/, "");
     const mountMw = (req, ctx, next) => {
-      ctx.mountPath = (ctx.mountPath || "") + base;
+      ctx.mountPath = (ctx.mountPath || "") + base2;
       return next(req, ctx);
     };
     const allExtra = extraMws.length === 0 && sub.globalMws.length === 0 ? [mountMw] : [mountMw, ...extraMws, ...sub.globalMws];
     const routes = [];
     this._collect(sub.root, "", routes);
     for (const { method, path, handler, middlewares } of routes) {
-      this._routeImpl(method, base + path, [...allExtra, ...middlewares, handler]);
+      this._routeImpl(method, base2 + path, [...allExtra, ...middlewares, handler]);
     }
     const wsRoutes = [];
     this._collectWs(sub.wsRoot, "", wsRoutes);
     for (const { path, handler, middlewares } of wsRoutes) {
-      this.ws(base + path, ...allExtra, ...middlewares, handler);
+      this.ws(base2 + path, ...allExtra, ...middlewares, handler);
     }
   }
   _collect(node, prefix, result) {
@@ -906,78 +906,6 @@ function cors(options) {
   };
 }
 
-// src/middleware/auth.ts
-import { createHmac, timingSafeEqual } from "node:crypto";
-function base64urlDecode(str) {
-  return Buffer.from(str.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8");
-}
-function sign(payload, secret) {
-  return createHmac("sha256", secret).update(payload).digest("base64url");
-}
-function parseCookie(cookieHeader, name) {
-  if (!cookieHeader) return null;
-  for (const c of cookieHeader.split(";")) {
-    const [key, ...rest] = c.trim().split("=");
-    if (key === name) return rest.join("=");
-  }
-  return null;
-}
-function auth(opts) {
-  return async (req, ctx, next) => {
-    if (opts.jwt) {
-      const cookie = opts.jwt.cookie ?? "token";
-      const token = parseCookie(req.headers.get("cookie"), cookie) ?? req.headers.get("authorization")?.replace(/^Bearer\s+/i, "");
-      if (token) {
-        try {
-          const [headerB64, payloadB64, sigB64] = token.split(".");
-          const expectedSig = sign(`${headerB64}.${payloadB64}`, opts.jwt.secret);
-          const sigBuf = Buffer.from(sigB64, "base64url");
-          const expectedBuf = Buffer.from(expectedSig, "base64url");
-          if (sigBuf.length === expectedBuf.length && timingSafeEqual(sigBuf, expectedBuf)) {
-            const payload = JSON.parse(base64urlDecode(payloadB64));
-            ctx.user = {
-              id: payload.sub ?? payload.id ?? "unknown",
-              role: payload.role,
-              tenant: payload.tenant,
-              ...payload
-            };
-          }
-        } catch {
-        }
-      }
-    }
-    if (opts.session && !ctx.user) {
-      const cookie = opts.session.cookie ?? "session";
-      const raw = parseCookie(req.headers.get("cookie"), cookie);
-      if (raw) {
-        try {
-          const [dataB64, sigB64] = raw.split(".");
-          const expectedSig = sign(dataB64, opts.session.secret);
-          const sigBuf = Buffer.from(sigB64, "base64url");
-          const expectedBuf = Buffer.from(expectedSig, "base64url");
-          if (sigBuf.length === expectedBuf.length && timingSafeEqual(sigBuf, expectedBuf)) {
-            const data = JSON.parse(base64urlDecode(dataB64));
-            const user = await opts.session.loadUser(data);
-            if (user) ctx.user = user;
-          }
-        } catch {
-        }
-      }
-    }
-    if (opts.apiKey && !ctx.user) {
-      const header = opts.apiKey.header ?? "authorization";
-      const prefix = opts.apiKey.prefix ?? "Bearer ";
-      const raw = req.headers.get(header);
-      if (raw?.startsWith(prefix)) {
-        const key = raw.slice(prefix.length);
-        const user = await opts.apiKey.validate(key);
-        if (user) ctx.user = user;
-      }
-    }
-    return next(req, ctx);
-  };
-}
-
 // src/middleware/static.ts
 import { open, realpath } from "node:fs/promises";
 import { extname, resolve, normalize, sep } from "node:path";
@@ -1192,7 +1120,7 @@ import { exec as cpExec } from "node:child_process";
 import { promisify } from "node:util";
 var runExec = promisify(cpExec);
 function sandbox(opts = {}) {
-  const base = resolve2(opts.baseDir ?? "/tmp/weifuwu-sandboxes");
+  const base2 = resolve2(opts.baseDir ?? "/tmp/weifuwu-sandboxes");
   const defaultTimeout = opts.timeout ?? 3e4;
   return async (req, ctx, next) => {
     let sessionId;
@@ -1201,7 +1129,7 @@ function sandbox(opts = {}) {
     } else {
       sessionId = crypto.randomUUID();
     }
-    const workDir = join2(base, encodeURIComponent(sessionId));
+    const workDir = join2(base2, encodeURIComponent(sessionId));
     await mkdir2(workDir, { recursive: true });
     function safePath(p) {
       const resolved = resolve2(workDir, normalize2(p).replace(/^[/\\]+/, ""));
@@ -2429,10 +2357,10 @@ function queue(opts) {
   const stats = () => ({ running, inflight, processed: _processed, failed: _failed, handlers: handlers.size, maxConcurrent: MAX_CONCURRENT });
   const mw = ((_req, ctx, next) => {
     ;
-    ctx.queue = q;
+    ctx.queue = q2;
     return next(_req, ctx);
   });
-  const q = mw;
+  const q2 = mw;
   mw.add = function add(type, payload, opts2) {
     const id = crypto3.randomUUID();
     let runAt;
@@ -2551,15 +2479,15 @@ function queue(opts) {
     });
     return r;
   };
-  q.cron = function(pattern, handler) {
+  q2.cron = function(pattern, handler) {
     const id = "__cron_" + pattern.replace(/[^a-zA-Z0-9]/g, "_") + "_" + crypto3.randomUUID().slice(0, 8);
-    q.process(id, async () => {
+    q2.process(id, async () => {
       await handler();
     });
-    q.add(id, {}, { schedule: pattern });
+    q2.add(id, {}, { schedule: pattern });
     return { stop: () => handlers.delete(id) };
   };
-  return q;
+  return q2;
 }
 
 // src/react/index.ts
@@ -3077,17 +3005,2238 @@ function agent(opts) {
     return next(req, ctx);
   };
 }
+
+// src/user/module.ts
+import { randomBytes, scryptSync, timingSafeEqual, createHmac } from "node:crypto";
+var DEFAULT_TABLE = "users";
+var DEFAULT_TOKEN_EXPIRY = 7 * 24 * 60 * 60 * 1e3;
+var SALT_LENGTH = 32;
+var KEY_LENGTH = 64;
+var HASH_ALGORITHM = "sha256";
+function hashPassword(password) {
+  const salt = randomBytes(SALT_LENGTH).toString("hex");
+  const key = scryptSync(password, salt, KEY_LENGTH).toString("hex");
+  return `scrypt:${salt}:${key}`;
+}
+async function verifyScrypt(password, stored) {
+  const parts = stored.split(":");
+  if (parts.length !== 3 || parts[0] !== "scrypt") return false;
+  const [, salt, key] = parts;
+  const expected = scryptSync(password, salt, KEY_LENGTH).toString("hex");
+  const a = Buffer.from(key, "hex");
+  const b = Buffer.from(expected, "hex");
+  if (a.length !== b.length) return false;
+  return timingSafeEqual(a, b);
+}
+function base64url(data) {
+  return Buffer.from(data).toString("base64url");
+}
+function base64urlDecode(str) {
+  return Buffer.from(str.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8");
+}
+function hmacSign(payload, secret) {
+  return createHmac(HASH_ALGORITHM, secret).update(payload).digest("base64url");
+}
+function tokenEncode(payload, secret) {
+  const header = base64url(JSON.stringify({ alg: "HS256", typ: "JWT" }));
+  const body = base64url(JSON.stringify(payload));
+  return `${header}.${body}.${hmacSign(`${header}.${body}`, secret)}`;
+}
+function tokenDecode(token, secret) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const [headerB64, payloadB64, sigB64] = parts;
+    const expectedSig = hmacSign(`${headerB64}.${payloadB64}`, secret);
+    const sigBuf = Buffer.from(sigB64, "base64url");
+    const expectedBuf = Buffer.from(expectedSig, "base64url");
+    if (sigBuf.length !== expectedBuf.length) return null;
+    if (!timingSafeEqual(sigBuf, expectedBuf)) return null;
+    const payload = JSON.parse(base64urlDecode(payloadB64));
+    if (payload.exp && payload.exp < Date.now()) return null;
+    return payload;
+  } catch {
+    return null;
+  }
+}
+function parseCookie(cookieHeader, name) {
+  if (!cookieHeader) return null;
+  for (const c of cookieHeader.split(";")) {
+    const [key, ...rest] = c.trim().split("=");
+    if (key === name) return rest.join("=");
+  }
+  return null;
+}
+function extractToken(req) {
+  return req.headers.get("authorization")?.replace(/^Bearer\s+/i, "") ?? parseCookie(req.headers.get("cookie"), "token") ?? null;
+}
+function toUserRecord(row) {
+  return {
+    id: row.id,
+    email: row.email,
+    name: row.name,
+    role: row.role,
+    avatar: row.avatar,
+    is_active: row.is_active,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    last_login_at: row.last_login_at
+  };
+}
+function getSqlFromCtx(ctx) {
+  const sql = ctx.sql;
+  if (!sql) {
+    throw new Error(
+      "user() requires postgres() middleware to be registered first.\nMake sure app.use(postgres()) is called before app.use(user())"
+    );
+  }
+  return sql;
+}
+var UserModule = class {
+  table;
+  secret;
+  tokenExpiry;
+  migrated = false;
+  constructor(opts) {
+    this.table = opts?.table ?? DEFAULT_TABLE;
+    this.secret = opts?.secret ?? process.env.JWT_SECRET ?? "change-me-in-production";
+    this.tokenExpiry = opts?.tokenExpiry ?? DEFAULT_TOKEN_EXPIRY;
+  }
+  // ── Migration ─────────────────────────────────────────────
+  async migrate(sql) {
+    if (this.migrated) return;
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS "${this.table}" (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        email       TEXT NOT NULL UNIQUE,
+        name        TEXT NOT NULL,
+        password    TEXT NOT NULL,
+        role        TEXT NOT NULL DEFAULT 'user',
+        avatar      TEXT,
+        is_active   BOOLEAN NOT NULL DEFAULT TRUE,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        last_login_at TIMESTAMPTZ
+      )
+    `);
+    await sql.unsafe(`CREATE INDEX IF NOT EXISTS "${this.table}_email_idx" ON "${this.table}" (email)`);
+    await sql.unsafe(`CREATE INDEX IF NOT EXISTS "${this.table}_role_idx" ON "${this.table}" (role)`);
+    this.migrated = true;
+  }
+  // ── Per-request bound API ─────────────────────────────────
+  /**
+   * Create a per-request `UserModuleAPI` bound to the request's SQL context.
+   * Called internally by the middleware. Thread-safe because each request
+   * gets its own closure with a captured `ctx`.
+   */
+  bind(ctx) {
+    const self = this;
+    const sql = getSqlFromCtx(ctx);
+    if (!this.migrated) {
+      this.migrate(sql).catch(() => {
+      });
+    }
+    return {
+      createUser(input) {
+        return self._createUser(input, sql);
+      },
+      register(input) {
+        return self._register(input, sql);
+      },
+      login(email, password) {
+        return self._login(email, password, sql);
+      },
+      getUserById(id) {
+        return self._getUserById(id, sql);
+      },
+      getUserByEmail(email) {
+        return self._getUserByEmail(email, sql);
+      },
+      updateUser(id, input) {
+        return self._updateUser(id, input, sql);
+      },
+      deleteUser(id) {
+        return self._deleteUser(id, sql);
+      },
+      listUsers(includeInactive = false) {
+        return self._listUsers(sql, includeInactive);
+      },
+      changePassword(id, currentPassword, newPassword) {
+        return self._changePassword(id, currentPassword, newPassword, sql);
+      },
+      verifyPassword(password, hash) {
+        return verifyScrypt(password, hash);
+      },
+      generateToken(user2) {
+        return Promise.resolve(self._generateToken(user2));
+      },
+      verifyToken(token) {
+        return Promise.resolve(self._verifyToken(token));
+      },
+      refreshToken(token) {
+        return Promise.resolve(self._refreshToken(token));
+      }
+    };
+  }
+  // ── Internal CRUD (take sql explicitly) ────────────────────
+  async ensureMigrated(sql) {
+    if (!this.migrated) await this.migrate(sql);
+  }
+  async _register(input, sql) {
+    const user2 = await this._createUser(input, sql);
+    const token = this._generateToken(user2);
+    return { user: user2, token };
+  }
+  async _createUser(input, sql) {
+    await this.ensureMigrated(sql);
+    const hash = hashPassword(input.password);
+    const role = input.role ?? "user";
+    const isActive = input.is_active ?? true;
+    const [row] = await sql.unsafe(
+      `INSERT INTO "${this.table}" (email, name, password, role, avatar, is_active)
+       VALUES ($1, $2, $3, $4, $5, $6)
+       RETURNING *`,
+      [input.email, input.name, hash, role, input.avatar ?? null, isActive]
+    );
+    if (!row) throw new Error("Failed to create user");
+    return toUserRecord(row);
+  }
+  async _getUserById(id, sql) {
+    await this.ensureMigrated(sql);
+    const [row] = await sql.unsafe(
+      `SELECT * FROM "${this.table}" WHERE id = $1`,
+      [id]
+    );
+    return row ? toUserRecord(row) : null;
+  }
+  async _getUserByEmail(email, sql) {
+    await this.ensureMigrated(sql);
+    const [row] = await sql.unsafe(
+      `SELECT * FROM "${this.table}" WHERE email = $1`,
+      [email]
+    );
+    return row ? toUserRecord(row) : null;
+  }
+  async _updateUser(id, input, sql) {
+    await this.ensureMigrated(sql);
+    const sets = [];
+    const values = [];
+    let idx = 1;
+    if (input.name !== void 0) {
+      sets.push(`name = $${idx++}`);
+      values.push(input.name);
+    }
+    if (input.email !== void 0) {
+      sets.push(`email = $${idx++}`);
+      values.push(input.email);
+    }
+    if (input.role !== void 0) {
+      sets.push(`role = $${idx++}`);
+      values.push(input.role);
+    }
+    if (input.avatar !== void 0) {
+      sets.push(`avatar = $${idx++}`);
+      values.push(input.avatar);
+    }
+    if (input.is_active !== void 0) {
+      sets.push(`is_active = $${idx++}`);
+      values.push(input.is_active);
+    }
+    if (input.password !== void 0) {
+      sets.push(`password = $${idx++}`);
+      values.push(hashPassword(input.password));
+    }
+    if (sets.length === 0) return this._getUserById(id, sql);
+    sets.push("updated_at = NOW()");
+    values.push(id);
+    const [row] = await sql.unsafe(
+      `UPDATE "${this.table}" SET ${sets.join(", ")} WHERE id = $${idx} RETURNING *`,
+      values
+    );
+    return row ? toUserRecord(row) : null;
+  }
+  async _deleteUser(id, sql) {
+    await this.ensureMigrated(sql);
+    const [row] = await sql.unsafe(
+      `UPDATE "${this.table}" SET is_active = FALSE, updated_at = NOW() WHERE id = $1 RETURNING id`,
+      [id]
+    );
+    return !!row;
+  }
+  async _listUsers(sql, includeInactive) {
+    await this.ensureMigrated(sql);
+    const rows = includeInactive ? await sql.unsafe(`SELECT * FROM "${this.table}" ORDER BY created_at DESC`) : await sql.unsafe(`SELECT * FROM "${this.table}" WHERE is_active = TRUE ORDER BY created_at DESC`);
+    return rows.map(toUserRecord);
+  }
+  async _login(email, password, sql) {
+    await this.ensureMigrated(sql);
+    const [row] = await sql.unsafe(
+      `SELECT * FROM "${this.table}" WHERE email = $1`,
+      [email]
+    );
+    if (!row) return null;
+    if (!await verifyScrypt(password, row.password)) return null;
+    const user2 = toUserRecord(row);
+    const token = this._generateToken(user2);
+    await sql.unsafe(`UPDATE "${this.table}" SET last_login_at = NOW() WHERE id = $1`, [user2.id]);
+    return { user: user2, token };
+  }
+  async _changePassword(id, currentPassword, newPassword, sql) {
+    await this.ensureMigrated(sql);
+    const [row] = await sql.unsafe(
+      `SELECT password FROM "${this.table}" WHERE id = $1`,
+      [id]
+    );
+    if (!row) return false;
+    if (!await verifyScrypt(currentPassword, row.password)) return false;
+    const hash = hashPassword(newPassword);
+    await sql.unsafe(
+      `UPDATE "${this.table}" SET password = $1, updated_at = NOW() WHERE id = $2`,
+      [hash, id]
+    );
+    return true;
+  }
+  // ── Token helpers (stateless, no sql needed) ────────────────
+  _generateToken(user2) {
+    const now = Date.now();
+    return tokenEncode(
+      { sub: user2.id, email: user2.email, role: user2.role, iat: now, exp: now + this.tokenExpiry },
+      this.secret
+    );
+  }
+  _verifyToken(token) {
+    return tokenDecode(token, this.secret);
+  }
+  _refreshToken(token) {
+    const payload = tokenDecode(token, this.secret);
+    if (!payload) return null;
+    const now = Date.now();
+    return tokenEncode(
+      { sub: payload.sub, email: payload.email, role: payload.role, iat: now, exp: now + this.tokenExpiry },
+      this.secret
+    );
+  }
+  // ── Middleware ──────────────────────────────────────────────
+  /**
+   * Middleware entry point. Injects `ctx.userModule` (per-request bound API)
+   * and resolves `ctx.user` from the Authorization header or `token` cookie.
+   */
+  async middleware(req, ctx, next) {
+    ctx.userModule = this.bind(ctx);
+    const token = extractToken(req);
+    if (token && !ctx.user) {
+      try {
+        const payload = tokenDecode(token, this.secret);
+        if (payload) {
+          const sql = getSqlFromCtx(ctx);
+          const [row] = await sql.unsafe(
+            `SELECT * FROM "${this.table}" WHERE id = $1`,
+            [payload.sub]
+          );
+          if (row) {
+            ctx.user = toUserRecord(row);
+          }
+        }
+      } catch {
+      }
+    }
+    return next(req, ctx);
+  }
+};
+
+// src/user/types.ts
+function requireRole(...roles) {
+  return (req, ctx, next) => {
+    if (!ctx.user) {
+      return new Response("Unauthorized", { status: 401 });
+    }
+    const userRole = ctx.user.role;
+    if (!userRole || !roles.includes(userRole)) {
+      return new Response("Forbidden", { status: 403 });
+    }
+    return next(req, ctx);
+  };
+}
+
+// src/user/index.ts
+function user(opts) {
+  const module = new UserModule(opts);
+  const mw = ((req, ctx, next) => {
+    return module.middleware(req, ctx, next);
+  });
+  mw.__meta = { injects: ["userModule", "user"], depends: ["sql"] };
+  return mw;
+}
+
+// src/messager/module.ts
+var DEFAULT_LIMIT = 50;
+var MAX_LIMIT = 200;
+var EDIT_WINDOW_MS = 24 * 60 * 60 * 1e3;
+function toConversation(row) {
+  return {
+    id: row.id,
+    type: row.type,
+    title: row.title,
+    created_by: row.created_by,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    participant_count: row.participant_count,
+    last_message: row.last_message ? row.last_message : void 0,
+    unread_count: row.unread_count
+  };
+}
+function toMessage(row) {
+  return {
+    id: row.id,
+    conversation_id: row.conversation_id,
+    sender_id: row.sender_id,
+    sender_name: row.sender_name,
+    body: row.body,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    edited: row.edited,
+    deleted_at: row.deleted_at
+  };
+}
+function getSql(ctx) {
+  const sql = ctx.sql;
+  if (!sql) {
+    throw new Error(
+      "messager() requires postgres() middleware to be registered first."
+    );
+  }
+  return sql;
+}
+var Messager = class {
+  migrated = false;
+  prefix;
+  usersTable;
+  constructor(opts) {
+    this.prefix = opts?.tablePrefix ?? "";
+    this.usersTable = opts?.usersTable ?? "users";
+  }
+  // ── Table names ────────────────────────────────────────────
+  get tConversations() {
+    return `"${this.prefix}conversations"`;
+  }
+  get tParticipants() {
+    return `"${this.prefix}participants"`;
+  }
+  get tMessages() {
+    return `"${this.prefix}messages"`;
+  }
+  get tUsers() {
+    return `"${this.usersTable}"`;
+  }
+  q(name) {
+    return `"${this.prefix}${name}"`;
+  }
+  // ── Migration ──────────────────────────────────────────────
+  async migrate(sql) {
+    if (this.migrated) return;
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("conversations")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        type        TEXT NOT NULL CHECK (type IN ('direct', 'group')),
+        title       TEXT,
+        created_by  UUID NOT NULL,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${this.q("conversations_updated_idx")}
+        ON ${this.q("conversations")} (updated_at DESC)
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("participants")} (
+        conversation_id UUID NOT NULL REFERENCES ${this.q("conversations")}(id) ON DELETE CASCADE,
+        user_id         UUID NOT NULL,
+        role            TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('member', 'admin')),
+        last_read_at    TIMESTAMPTZ,
+        joined_at       TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        is_active       BOOLEAN NOT NULL DEFAULT TRUE,
+        PRIMARY KEY (conversation_id, user_id)
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${this.q("participants_user_idx")}
+        ON ${this.q("participants")} (user_id, is_active)
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("messages")} (
+        id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        conversation_id UUID NOT NULL REFERENCES ${this.q("conversations")}(id) ON DELETE CASCADE,
+        sender_id       UUID NOT NULL,
+        body            TEXT NOT NULL,
+        created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        edited          BOOLEAN NOT NULL DEFAULT FALSE,
+        deleted_at      TIMESTAMPTZ
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${this.q("messages_conv_idx")}
+        ON ${this.q("messages")} (conversation_id, created_at DESC)
+    `);
+    this.migrated = true;
+  }
+  async ensureMigrated(sql) {
+    if (!this.migrated) await this.migrate(sql);
+  }
+  // ── Per-request bound API ──────────────────────────────────
+  bind(ctx) {
+    const self = this;
+    const sql = getSql(ctx);
+    if (!this.migrated) {
+      this.migrate(sql).catch(() => {
+      });
+    }
+    function currentUserId3() {
+      const u = ctx.user;
+      if (!u?.id) throw new Error("messager() requires user() middleware \u2014 ctx.user is missing");
+      return u.id;
+    }
+    function broadcast(conversationId, event, data) {
+      try {
+        const ws = ctx.ws;
+        if (ws && typeof ws.sendRoom === "function") {
+          ;
+          ws.sendRoom(`conversation:${conversationId}`, {
+            type: event,
+            ...data
+          });
+        }
+      } catch {
+      }
+    }
+    return {
+      // ── Conversations ──────────────────────────────────────
+      async createDirectConversation(otherUserId) {
+        const me = currentUserId3();
+        const [, otherId] = me < otherUserId ? [me, otherUserId] : [otherUserId, me];
+        await self.ensureMigrated(sql);
+        const existing = await sql.unsafe(`
+          SELECT c.id FROM ${self.q("conversations")} c
+          WHERE c.type = 'direct'
+            AND EXISTS (SELECT 1 FROM ${self.q("participants")} p1
+                        WHERE p1.conversation_id = c.id AND p1.user_id = $1 AND p1.is_active = TRUE)
+            AND EXISTS (SELECT 1 FROM ${self.q("participants")} p2
+                        WHERE p2.conversation_id = c.id AND p2.user_id = $2 AND p2.is_active = TRUE)
+          ORDER BY c.created_at ASC LIMIT 1
+        `, [me, otherId]);
+        if (existing.length > 0) {
+          return self._getConversationById(existing[0].id, sql, me);
+        }
+        const [conv] = await sql.unsafe(`
+          INSERT INTO ${self.q("conversations")} (type, created_by) VALUES ('direct', $1) RETURNING *
+        `, [me]);
+        await sql.unsafe(`
+          INSERT INTO ${self.q("participants")} (conversation_id, user_id, role)
+          VALUES ($1, $2, 'member'), ($1, $3, 'member')
+          ON CONFLICT (conversation_id, user_id) DO NOTHING
+        `, [conv.id, me, otherId]);
+        return toConversation(conv);
+      },
+      async createGroupConversation(title, userIds) {
+        const me = currentUserId3();
+        const all = [me, ...userIds.filter((id) => id !== me)];
+        await self.ensureMigrated(sql);
+        const [conv] = await sql.unsafe(`
+          INSERT INTO ${self.q("conversations")} (type, title, created_by)
+          VALUES ('group', $1, $2) RETURNING *
+        `, [title, me]);
+        const values = all.map(
+          (uid, i) => `($${i * 2 + 1}, $${i * 2 + 2}, ${uid === me ? "'admin'" : "'member'"})`
+        ).join(", ");
+        await sql.unsafe(`
+          INSERT INTO ${self.q("participants")} (conversation_id, user_id, role)
+          VALUES ${values}
+          ON CONFLICT (conversation_id, user_id) DO NOTHING
+        `, all.flatMap((uid) => [conv.id, uid]));
+        return toConversation(conv);
+      },
+      async getConversation(conversationId) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        return self._getConversationById(conversationId, sql, me);
+      },
+      async getConversations() {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(`
+          SELECT
+            c.*,
+            (SELECT COUNT(*) FROM ${self.q("participants")} p
+             WHERE p.conversation_id = c.id AND p.is_active = TRUE) AS participant_count,
+            (SELECT row_to_json(msg.*) FROM (
+              SELECT m.id, m.body, m.sender_id, m.created_at,
+                (SELECT u.name FROM ${self.tUsers} u WHERE u.id = m.sender_id) AS sender_name
+              FROM ${self.q("messages")} m
+              WHERE m.conversation_id = c.id AND m.deleted_at IS NULL
+              ORDER BY m.created_at DESC LIMIT 1
+            ) msg) AS last_message,
+            (SELECT COUNT(*) FROM ${self.q("messages")} m
+             WHERE m.conversation_id = c.id
+               AND m.deleted_at IS NULL
+               AND m.created_at > COALESCE(p.last_read_at, '1970-01-01'::timestamptz)
+               AND m.sender_id != $1) AS unread_count
+          FROM ${self.q("conversations")} c
+          JOIN ${self.q("participants")} p ON p.conversation_id = c.id AND p.user_id = $1 AND p.is_active = TRUE
+          ORDER BY c.updated_at DESC
+        `, [me]);
+        return rows.map(toConversation);
+      },
+      async addParticipants(conversationId, userIds) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const [caller] = await sql.unsafe(`
+          SELECT role FROM ${self.q("participants")}
+          WHERE conversation_id = $1 AND user_id = $2 AND is_active = TRUE
+        `, [conversationId, me]);
+        if (!caller) throw new Error("Not a participant");
+        if (caller.role !== "admin") throw new Error("Only admins can add participants");
+        const values = userIds.map(
+          (uid, i) => `($1, $${i + 2}, 'member')`
+        ).join(", ");
+        await sql.unsafe(`
+          INSERT INTO ${self.q("participants")} (conversation_id, user_id, role)
+          VALUES ${values}
+          ON CONFLICT (conversation_id, user_id) DO UPDATE SET is_active = TRUE
+        `, [conversationId, ...userIds]);
+        await sql.unsafe(`UPDATE ${self.q("conversations")} SET updated_at = NOW() WHERE id = $1`, [conversationId]);
+      },
+      async removeParticipant(conversationId, targetUserId) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const targetId = targetUserId ?? me;
+        if (targetId !== me) {
+          const [caller] = await sql.unsafe(`
+            SELECT role FROM ${self.q("participants")}
+            WHERE conversation_id = $1 AND user_id = $2 AND is_active = TRUE
+          `, [conversationId, me]);
+          if (!caller || caller.role !== "admin") throw new Error("Only admins can remove participants");
+        }
+        const [row] = await sql.unsafe(`
+          UPDATE ${self.q("participants")} SET is_active = FALSE
+          WHERE conversation_id = $1 AND user_id = $2 AND is_active = TRUE
+          RETURNING user_id
+        `, [conversationId, targetId]);
+        if (row) {
+          await sql.unsafe(`UPDATE ${self.q("conversations")} SET updated_at = NOW() WHERE id = $1`, [conversationId]);
+        }
+        return !!row;
+      },
+      // ── Messages ───────────────────────────────────────────
+      async sendMessage(conversationId, body) {
+        const me = currentUserId3();
+        if (!body.trim()) throw new Error("Message body cannot be empty");
+        await self.ensureMigrated(sql);
+        const [part] = await sql.unsafe(`
+          SELECT user_id FROM ${self.q("participants")}
+          WHERE conversation_id = $1 AND user_id = $2 AND is_active = TRUE
+        `, [conversationId, me]);
+        if (!part) throw new Error("Not a participant in this conversation");
+        const [msg] = await sql.unsafe(`
+          INSERT INTO ${self.q("messages")} (conversation_id, sender_id, body)
+          VALUES ($1, $2, $3) RETURNING *
+        `, [conversationId, me, body.trim()]);
+        await sql.unsafe(`UPDATE ${self.q("conversations")} SET updated_at = NOW() WHERE id = $1`, [conversationId]);
+        const message = toMessage(msg);
+        message.sender_name = ctx.user ? ctx.user.name : void 0;
+        broadcast(conversationId, "new_message", { message });
+        return message;
+      },
+      async getMessages(conversationId, opts) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const [part] = await sql.unsafe(`
+          SELECT user_id FROM ${self.q("participants")}
+          WHERE conversation_id = $1 AND user_id = $2 AND is_active = TRUE
+        `, [conversationId, me]);
+        if (!part) return [];
+        const limit = Math.min(opts?.limit ?? DEFAULT_LIMIT, MAX_LIMIT);
+        let rows;
+        if (opts?.before) {
+          const [cursor] = await sql.unsafe(`
+            SELECT created_at FROM ${self.q("messages")} WHERE id = $1
+          `, [opts.before]);
+          if (cursor) {
+            rows = await sql.unsafe(`
+              SELECT m.*, (SELECT u.name FROM ${self.tUsers} u WHERE u.id = m.sender_id) AS sender_name
+              FROM ${self.q("messages")} m
+              WHERE m.conversation_id = $1 AND m.deleted_at IS NULL AND m.created_at < $2
+              ORDER BY m.created_at DESC LIMIT $3
+            `, [conversationId, cursor.created_at, limit]);
+          } else {
+            rows = [];
+          }
+        } else {
+          rows = await sql.unsafe(`
+            SELECT m.*, (SELECT u.name FROM ${self.tUsers} u WHERE u.id = m.sender_id) AS sender_name
+            FROM ${self.q("messages")} m
+            WHERE m.conversation_id = $1 AND m.deleted_at IS NULL
+            ORDER BY m.created_at DESC LIMIT $2
+          `, [conversationId, limit]);
+        }
+        return rows.map(toMessage).reverse();
+      },
+      async editMessage(messageId, body) {
+        const me = currentUserId3();
+        if (!body.trim()) throw new Error("Message body cannot be empty");
+        await self.ensureMigrated(sql);
+        const [msg] = await sql.unsafe(`
+          SELECT * FROM ${self.q("messages")} WHERE id = $1 AND sender_id = $2 AND deleted_at IS NULL
+        `, [messageId, me]);
+        if (!msg) return null;
+        const elapsed = Date.now() - new Date(msg.created_at).getTime();
+        if (elapsed > EDIT_WINDOW_MS) return null;
+        const [updated] = await sql.unsafe(`
+          UPDATE ${self.q("messages")} SET body = $1, edited = TRUE, updated_at = NOW()
+          WHERE id = $2 RETURNING *
+        `, [body.trim(), messageId]);
+        const message = toMessage(updated);
+        broadcast(msg.conversation_id, "edit_message", { message });
+        return message;
+      },
+      async deleteMessage(messageId) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const [msg] = await sql.unsafe(`
+          SELECT * FROM ${self.q("messages")} WHERE id = $1 AND sender_id = $2 AND deleted_at IS NULL
+        `, [messageId, me]);
+        if (!msg) return false;
+        await sql.unsafe(`
+          UPDATE ${self.q("messages")} SET deleted_at = NOW() WHERE id = $1
+        `, [messageId]);
+        broadcast(msg.conversation_id, "delete_message", { messageId });
+        return true;
+      },
+      // ── Read state ──────────────────────────────────────
+      async markRead(conversationId) {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        await sql.unsafe(`
+          INSERT INTO ${self.q("participants")} (conversation_id, user_id, role, last_read_at)
+          VALUES ($1, $2, 'member', NOW())
+          ON CONFLICT (conversation_id, user_id)
+          DO UPDATE SET last_read_at = NOW()
+        `, [conversationId, me]);
+      },
+      async getUnreadCount() {
+        const me = currentUserId3();
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(`
+          SELECT
+            p.conversation_id,
+            COUNT(m.id)::INT AS cnt
+          FROM ${self.q("participants")} p
+          JOIN ${self.q("messages")} m ON m.conversation_id = p.conversation_id
+            AND m.deleted_at IS NULL
+            AND m.created_at > COALESCE(p.last_read_at, '1970-01-01'::timestamptz)
+            AND m.sender_id != $1
+          WHERE p.user_id = $1 AND p.is_active = TRUE
+          GROUP BY p.conversation_id
+        `, [me]);
+        const byConversation = {};
+        let total = 0;
+        for (const row of rows) {
+          const cnt = row.cnt;
+          byConversation[row.conversation_id] = cnt;
+          total += cnt;
+        }
+        return { total, byConversation };
+      }
+    };
+  }
+  // ── Internal ──────────────────────────────────────────────
+  async _getConversationById(id, sql, userId) {
+    const [row] = await sql.unsafe(`
+      SELECT c.*,
+        (SELECT COUNT(*) FROM ${this.q("participants")} p
+         WHERE p.conversation_id = c.id AND p.is_active = TRUE) AS participant_count
+      FROM ${this.q("conversations")} c
+      JOIN ${this.q("participants")} p ON p.conversation_id = c.id AND p.user_id = $1 AND p.is_active = TRUE
+      WHERE c.id = $2
+    `, [userId, id]);
+    return row ? toConversation(row) : null;
+  }
+  // ── Middleware ─────────────────────────────────────────────
+  async middleware(req, ctx, next) {
+    ctx.messager = this.bind(ctx);
+    return next(req, ctx);
+  }
+};
+
+// src/messager/index.ts
+function messager(opts) {
+  const module = new Messager(opts);
+  const mw = ((req, ctx, next) => {
+    return module.middleware(req, ctx, next);
+  });
+  mw.__meta = { injects: ["messager"], depends: ["sql", "user"] };
+  return mw;
+}
+
+// src/base/module.ts
+var SLOTS = {
+  text: { prefix: "text", count: 64 },
+  number: { prefix: "number", count: 32 },
+  date: { prefix: "date", count: 8 },
+  vector: { prefix: "vector", count: 4 },
+  search: { prefix: "search", count: 4 }
+};
+var TYPE_TO_SLOT = {
+  string: "text",
+  text: "text",
+  number: "number",
+  boolean: "text",
+  // stored as 'true'/'false' in text
+  date: "date",
+  datetime: "date",
+  vector: "vector",
+  search: "search",
+  relation: "text",
+  // stores UUID
+  json: "ext"
+};
+var DEFAULT_LIMIT2 = 50;
+var MAX_LIMIT2 = 200;
+function q(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100) || "untitled";
+}
+function getSql2(ctx) {
+  const sql = ctx.sql;
+  if (!sql) throw new Error("base() requires postgres() middleware");
+  return sql;
+}
+function currentUserId(ctx) {
+  const u = ctx.user;
+  if (!u?.id) throw new Error("base() requires user() middleware");
+  return u.id;
+}
+function normalizeValue(val) {
+  if (val === void 0) return null;
+  if (typeof val === "boolean") return val ? "true" : "false";
+  if (Array.isArray(val)) return JSON.stringify(val);
+  if (typeof val === "object" && val !== null) return JSON.stringify(val);
+  return val;
+}
+function toBaseDef(row) {
+  let tables = [];
+  const raw = row.tables;
+  if (typeof raw === "string") {
+    try {
+      tables = JSON.parse(raw);
+    } catch {
+    }
+  } else if (Array.isArray(raw)) {
+    tables = raw;
+  }
+  return {
+    id: row.id,
+    name: row.name,
+    slug: row.slug,
+    description: row.description,
+    tables,
+    created_by: row.created_by,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+var Base = class {
+  migrated = false;
+  hasVector = false;
+  managementSchema;
+  usersTable;
+  constructor(opts) {
+    this.managementSchema = opts?.managementSchema ?? "public";
+    this.usersTable = opts?.usersTable ?? "users";
+  }
+  ms(name) {
+    return `${q(this.managementSchema)}.${q(name)}`;
+  }
+  // ── Migration ──────────────────────────────────────────────
+  async migrate(sql) {
+    if (this.migrated) return;
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.ms("base_bases")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name        TEXT NOT NULL,
+        slug        TEXT NOT NULL UNIQUE,
+        description TEXT,
+        tables      JSONB NOT NULL DEFAULT '[]'::jsonb,
+        created_by  UUID NOT NULL,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.ms("base_column_map")} (
+        base_id     UUID NOT NULL,
+        table_name  TEXT NOT NULL,
+        field_name  TEXT NOT NULL,
+        field_type  TEXT NOT NULL,
+        physical    TEXT NOT NULL,
+        config      JSONB NOT NULL DEFAULT '{}'::jsonb,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        PRIMARY KEY (base_id, table_name, field_name),
+        UNIQUE (base_id, table_name, physical)
+      )
+    `);
+    const textCols = Array.from({ length: SLOTS.text.count }, (_, i) => `text${String(i + 1).padStart(3, "0")} TEXT`);
+    const numCols = Array.from({ length: SLOTS.number.count }, (_, i) => `number${String(i + 1).padStart(3, "0")} DOUBLE PRECISION`);
+    const dateCols = Array.from({ length: SLOTS.date.count }, (_, i) => `date${String(i + 1).padStart(3, "0")} TIMESTAMPTZ`);
+    await sql.unsafe(`CREATE EXTENSION IF NOT EXISTS vector`);
+    let hasVector = false;
+    try {
+      const extRows = await sql.unsafe(`SELECT 1 FROM pg_extension WHERE extname = 'vector'`);
+      hasVector = extRows.length > 0;
+    } catch {
+    }
+    const vectorCols = hasVector ? Array.from({ length: SLOTS.vector.count }, (_, i) => `vector${String(i + 1).padStart(3, "0")} VECTOR(1536)`) : [];
+    const searchCols = Array.from({ length: SLOTS.search.count }, (_, i) => `search${String(i + 1).padStart(3, "0")} TEXT`);
+    const allCols = [...textCols, ...numCols, ...dateCols, ...vectorCols, ...searchCols];
+    await sql.unsafe(
+      `
+      CREATE TABLE IF NOT EXISTS ${this.ms("base_data")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        base_id     UUID NOT NULL,
+        table_name  TEXT NOT NULL,
+        ${allCols.join(",\n        ")},
+        ext         JSONB NOT NULL DEFAULT '{}'::jsonb,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )`
+    );
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS base_data_base_table_idx
+        ON ${this.ms("base_data")} (base_id, table_name)
+    `);
+    if (hasVector) {
+      await sql.unsafe(`
+        CREATE TABLE IF NOT EXISTS ${this.ms("base_vectors")} (
+          id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+          base_id     UUID NOT NULL,
+          table_name  TEXT NOT NULL,
+          field_name  TEXT NOT NULL,
+          row_id      UUID NOT NULL,
+          embedding   VECTOR(1536) NOT NULL,
+          created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        )
+      `);
+      await sql.unsafe(`
+        CREATE INDEX IF NOT EXISTS base_vectors_lookup_idx
+          ON ${this.ms("base_vectors")} (base_id, table_name, field_name)
+      `);
+    }
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.ms("base_search")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        base_id     UUID NOT NULL,
+        table_name  TEXT NOT NULL,
+        field_name  TEXT NOT NULL,
+        row_id      UUID NOT NULL,
+        content     TEXT NOT NULL,
+        tsv         TSVECTOR NOT NULL,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS base_search_tsv_idx
+        ON ${this.ms("base_search")} USING GIN (tsv)
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS base_search_lookup_idx
+        ON ${this.ms("base_search")} (base_id, table_name, field_name)
+    `);
+    this.migrated = true;
+    this.hasVector = hasVector;
+  }
+  async ensureMigrated(sql) {
+    if (!this.migrated) await this.migrate(sql);
+  }
+  // ── Slot allocator ─────────────────────────────────────────
+  async allocateSlot(sql, baseId, tableName, fieldType) {
+    const slotGroup = TYPE_TO_SLOT[fieldType];
+    if (!slotGroup || slotGroup === "ext") {
+      return "ext";
+    }
+    const range = SLOTS[slotGroup];
+    if (!range) return "ext";
+    const used = await sql.unsafe(
+      `SELECT physical FROM ${this.ms("base_column_map")}
+       WHERE base_id = $1 AND table_name = $2 AND physical LIKE $3`,
+      [baseId, tableName, `${range.prefix}%`]
+    );
+    const usedSet = new Set(used.map((r) => r.physical));
+    for (let i = 1; i <= range.count; i++) {
+      const candidate = `${range.prefix}${String(i).padStart(3, "0")}`;
+      if (!usedSet.has(candidate)) {
+        return candidate;
+      }
+    }
+    return "ext";
+  }
+  // ── Physical column type ───────────────────────────────────
+  physicalType(slotName, _fieldType) {
+    if (slotName.startsWith("text") || slotName.startsWith("search")) {
+      return "text";
+    }
+    if (slotName.startsWith("number")) return "number";
+    if (slotName.startsWith("date")) return "date";
+    if (slotName.startsWith("vector")) return "vector";
+    return "jsonb";
+  }
+  // ── Get column map for a table ─────────────────────────────
+  async getColumnMap(sql, baseId, tableName) {
+    const rows = await sql.unsafe(
+      `SELECT field_name, field_type, physical
+       FROM ${this.ms("base_column_map")}
+       WHERE base_id = $1 AND table_name = $2
+       ORDER BY physical`,
+      [baseId, tableName]
+    );
+    return rows.map((r) => ({
+      field_name: r.field_name,
+      physical: r.physical,
+      field_type: r.field_type
+    }));
+  }
+  // ── Convert data row to field/value pairs ──────────────────
+  splitFields(colMap, data) {
+    const slotValues = {};
+    const extValues = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (key === "id") continue;
+      if (value === void 0) continue;
+      const mapping = colMap.find((m) => m.field_name === key);
+      if (mapping && mapping.physical !== "ext") {
+        slotValues[mapping.physical] = value;
+      } else {
+        extValues[key] = value;
+      }
+    }
+    return { slotValues, extValues };
+  }
+  // ── Convert row to field/value pairs (reverse) ─────────────
+  reconstructRow(colMap, row) {
+    const result = { ...row };
+    for (const m of colMap) {
+      if (m.physical !== "ext") {
+        if (m.physical in result) {
+          let val = result[m.physical];
+          if (m.field_type === "boolean") {
+            val = val === "true" || val === true;
+          } else if (m.field_type === "number") {
+            if (typeof val === "string") val = parseFloat(val);
+          }
+          result[m.field_name] = val;
+          delete result[m.physical];
+        }
+      }
+    }
+    if (result.ext) {
+      let extData = result.ext;
+      if (typeof extData === "string") {
+        try {
+          extData = JSON.parse(extData);
+        } catch {
+          extData = {};
+        }
+      }
+      if (typeof extData === "object" && extData !== null) {
+        for (const [k, v] of Object.entries(extData)) {
+          result[k] = v;
+        }
+      }
+    }
+    delete result.ext;
+    return result;
+  }
+  // ── Build WHERE clause from filter ─────────────────────────
+  buildFilter(colMap, filter, startAt = 1) {
+    const conditions = [];
+    const values = [];
+    let idx = startAt;
+    for (const [key, val] of Object.entries(filter)) {
+      if (val === void 0 || val === null) continue;
+      const mapping = colMap.find((m) => m.field_name === key);
+      if (mapping && mapping.physical !== "ext") {
+        conditions.push(`${q(mapping.physical)}::text = $${idx++}`);
+        values.push(val);
+      } else {
+        conditions.push(`ext @> $${idx++}::jsonb`);
+        values.push(JSON.stringify({ [key]: val }));
+      }
+    }
+    return { conditions, values };
+  }
+  // ── Per-request bound API ──────────────────────────────────
+  bind(ctx) {
+    const self = this;
+    const sql = getSql2(ctx);
+    if (!this.migrated) {
+      this.migrate(sql).catch(() => {
+      });
+    }
+    async function ensureBase(baseId) {
+      const [row] = await sql.unsafe(
+        `SELECT * FROM ${self.ms("base_bases")} WHERE id = $1 LIMIT 1`,
+        [baseId]
+      );
+      if (!row) throw new Error("Base not found");
+      return row;
+    }
+    return {
+      // ── Create ──────────────────────────────────────────
+      async create(input) {
+        const userId = currentUserId(ctx);
+        await self.ensureMigrated(sql);
+        const slug = input.slug || slugify(input.name);
+        const tables = input.tables || [];
+        const [baseRow] = await sql.unsafe(
+          `
+          INSERT INTO ${self.ms("base_bases")} (name, slug, description, tables, created_by)
+          VALUES ($1, $2, $3, $4, $5) RETURNING *
+        `,
+          [input.name, slug, input.description ?? null, tables, userId]
+        );
+        for (const table of tables) {
+          for (const [fieldName, fieldSchema] of Object.entries(table.fields)) {
+            const physical = await self.allocateSlot(sql, baseRow.id, table.name, fieldSchema.type);
+            await sql.unsafe(`
+              INSERT INTO ${self.ms("base_column_map")} (base_id, table_name, field_name, field_type, physical, config)
+              VALUES ($1, $2, $3, $4, $5, $6)
+            `, [baseRow.id, table.name, fieldName, fieldSchema.type, physical, fieldSchema]);
+          }
+        }
+        return toBaseDef(baseRow);
+      },
+      // ── List ────────────────────────────────────────────
+      async list() {
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(
+          `SELECT * FROM ${self.ms("base_bases")} ORDER BY created_at DESC`
+        );
+        return rows.map(toBaseDef);
+      },
+      // ── Get ─────────────────────────────────────────────
+      async get(id) {
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `SELECT * FROM ${self.ms("base_bases")} WHERE id = $1 LIMIT 1`,
+          [id]
+        );
+        return row ? toBaseDef(row) : null;
+      },
+      async getBySlug(slug) {
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `SELECT * FROM ${self.ms("base_bases")} WHERE slug = $1 LIMIT 1`,
+          [slug]
+        );
+        return row ? toBaseDef(row) : null;
+      },
+      // ── Update ──────────────────────────────────────────
+      async update(id, input) {
+        await self.ensureMigrated(sql);
+        const sets = [];
+        const values = [];
+        let idx = 1;
+        if (input.name !== void 0) {
+          sets.push(`name = $${idx++}`);
+          values.push(input.name);
+        }
+        if (input.description !== void 0) {
+          sets.push(`description = $${idx++}`);
+          values.push(input.description);
+        }
+        if (sets.length === 0) return null;
+        sets.push("updated_at = NOW()");
+        values.push(id);
+        const [row] = await sql.unsafe(
+          `UPDATE ${self.ms("base_bases")} SET ${sets.join(", ")} WHERE id = $${idx} RETURNING *`,
+          values
+        );
+        return row ? toBaseDef(row) : null;
+      },
+      // ── Delete ──────────────────────────────────────────
+      async delete(id) {
+        await self.ensureMigrated(sql);
+        const [base2] = await sql.unsafe(`SELECT id FROM ${self.ms("base_bases")} WHERE id = $1 LIMIT 1`, [id]);
+        if (!base2) return false;
+        await sql.unsafe(`DELETE FROM ${self.ms("base_data")} WHERE base_id = $1`, [id]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_vectors")} WHERE base_id = $1`, [id]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_search")} WHERE base_id = $1`, [id]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_column_map")} WHERE base_id = $1`, [id]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_bases")} WHERE id = $1`, [id]);
+        return true;
+      },
+      // ── Define table ─────────────────────────────────────
+      async defineTable(baseId, schema) {
+        await self.ensureMigrated(sql);
+        const baseRow = await ensureBase(baseId);
+        const tables = Array.isArray(baseRow.tables) ? baseRow.tables : [];
+        if (tables.some((t) => t.name === schema.name)) {
+          throw new Error(`Table "${schema.name}" already exists`);
+        }
+        for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
+          const physical = await self.allocateSlot(sql, baseId, schema.name, fieldSchema.type);
+          await sql.unsafe(`
+            INSERT INTO ${self.ms("base_column_map")} (base_id, table_name, field_name, field_type, physical, config)
+            VALUES ($1, $2, $3, $4, $5, $6)
+          `, [baseId, schema.name, fieldName, fieldSchema.type, physical, fieldSchema]);
+        }
+        const newTables = [...tables, schema];
+        const [row] = await sql.unsafe(
+          `UPDATE ${self.ms("base_bases")} SET tables = $1, updated_at = NOW() WHERE id = $2 RETURNING *`,
+          [newTables, baseId]
+        );
+        return toBaseDef(row);
+      },
+      // ── Update table ─────────────────────────────────────
+      async updateTable(baseId, tableName, schema) {
+        await self.ensureMigrated(sql);
+        const baseRow = await ensureBase(baseId);
+        const tables = Array.isArray(baseRow.tables) ? baseRow.tables : [];
+        const idx = tables.findIndex((t) => t.name === tableName);
+        if (idx === -1) throw new Error(`Table "${tableName}" not found`);
+        const existing = tables[idx];
+        const existingFields = Object.keys(existing.fields);
+        for (const [fieldName, fieldSchema] of Object.entries(schema.fields)) {
+          if (!existingFields.includes(fieldName)) {
+            const physical = await self.allocateSlot(sql, baseId, tableName, fieldSchema.type);
+            await sql.unsafe(`
+              INSERT INTO ${self.ms("base_column_map")} (base_id, table_name, field_name, field_type, physical, config)
+              VALUES ($1, $2, $3, $4, $5, $6)
+              ON CONFLICT (base_id, table_name, field_name) DO UPDATE SET field_type = $4, config = $6
+            `, [baseId, tableName, fieldName, fieldSchema.type, physical, fieldSchema]);
+          }
+        }
+        const newTables = [...tables];
+        newTables[idx] = schema;
+        const [row] = await sql.unsafe(
+          `UPDATE ${self.ms("base_bases")} SET tables = $1, updated_at = NOW() WHERE id = $2 RETURNING *`,
+          [newTables, baseId]
+        );
+        return toBaseDef(row);
+      },
+      // ── Remove table ─────────────────────────────────────
+      async removeTable(baseId, tableName) {
+        await self.ensureMigrated(sql);
+        const baseRow = await ensureBase(baseId);
+        const tables = Array.isArray(baseRow.tables) ? baseRow.tables : [];
+        if (!tables.some((t) => t.name === tableName)) return null;
+        await sql.unsafe(`DELETE FROM ${self.ms("base_data")} WHERE base_id = $1 AND table_name = $2`, [baseId, tableName]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_vectors")} WHERE base_id = $1 AND table_name = $2`, [baseId, tableName]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_search")} WHERE base_id = $1 AND table_name = $2`, [baseId, tableName]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_column_map")} WHERE base_id = $1 AND table_name = $2`, [baseId, tableName]);
+        const newTables = tables.filter((t) => t.name !== tableName);
+        const [row] = await sql.unsafe(
+          `UPDATE ${self.ms("base_bases")} SET tables = $1, updated_at = NOW() WHERE id = $2 RETURNING *`,
+          [newTables, baseId]
+        );
+        return toBaseDef(row);
+      },
+      // ── Insert ──────────────────────────────────────────
+      async insert(baseId, table, data) {
+        await self.ensureMigrated(sql);
+        await ensureBase(baseId);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        const { slotValues, extValues } = self.splitFields(colMap, data);
+        const cols = ["base_id", "table_name"];
+        const vals = [baseId, table];
+        for (const [phys, val] of Object.entries(slotValues)) {
+          cols.push(q(phys));
+          vals.push(normalizeValue(val));
+        }
+        cols.push("ext");
+        vals.push(JSON.stringify(extValues));
+        const placeholders = vals.map((_, i) => `$${i + 1}`);
+        const [row] = await sql.unsafe(`
+          INSERT INTO ${self.ms("base_data")} (${cols.join(", ")})
+          VALUES (${placeholders.join(", ")})
+          RETURNING *
+        `, vals);
+        for (const [fieldName, val] of Object.entries(data)) {
+          if (fieldName === "id") continue;
+          const mapping = colMap.find((m) => m.field_name === fieldName);
+          if (!mapping) continue;
+          if (mapping.field_type === "vector" && Array.isArray(val) && self.hasVector) {
+            await sql.unsafe(`
+              INSERT INTO ${self.ms("base_vectors")} (base_id, table_name, field_name, row_id, embedding)
+              VALUES ($1, $2, $3, $4, $5::vector)
+              ON CONFLICT DO NOTHING
+            `, [baseId, table, fieldName, row.id, JSON.stringify(val)]);
+          }
+          if (mapping.field_type === "search" && typeof val === "string") {
+            await sql.unsafe(`
+              INSERT INTO ${self.ms("base_search")} (base_id, table_name, field_name, row_id, content, tsv)
+              VALUES ($1, $2, $3, $4, $5, to_tsvector('simple', $5))
+              ON CONFLICT DO NOTHING
+            `, [baseId, table, fieldName, row.id, val]);
+          }
+        }
+        return self.reconstructRow(colMap, row);
+      },
+      // ── Get row ──────────────────────────────────────────
+      async getRow(baseId, table, id) {
+        await self.ensureMigrated(sql);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        const [row] = await sql.unsafe(
+          `SELECT * FROM ${self.ms("base_data")} WHERE base_id = $1 AND table_name = $2 AND id = $3 LIMIT 1`,
+          [baseId, table, id]
+        );
+        if (!row) return null;
+        return self.reconstructRow(colMap, row);
+      },
+      // ── Update row ───────────────────────────────────────
+      async updateRow(baseId, table, id, data) {
+        await self.ensureMigrated(sql);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        const { slotValues, extValues } = self.splitFields(colMap, data);
+        const sets = ["updated_at = NOW()"];
+        const vals = [];
+        let idx = 1;
+        for (const [phys, val] of Object.entries(slotValues)) {
+          sets.push(`${q(phys)} = $${idx++}`);
+          vals.push(normalizeValue(val));
+        }
+        if (Object.keys(extValues).length > 0) {
+          sets.push(`ext = ext || $${idx++}::jsonb`);
+          vals.push(JSON.stringify(extValues));
+        }
+        if (sets.length === 1) {
+          return null;
+        }
+        vals.push(baseId, table, id);
+        const [row] = await sql.unsafe(`
+          UPDATE ${self.ms("base_data")} SET ${sets.join(", ")}
+          WHERE base_id = $${idx} AND table_name = $${idx + 1} AND id = $${idx + 2}
+          RETURNING *
+        `, vals);
+        if (!row) return null;
+        return self.reconstructRow(colMap, row);
+      },
+      // ── Delete row ───────────────────────────────────────
+      async deleteRow(baseId, table, id) {
+        await self.ensureMigrated(sql);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_vectors")} WHERE base_id = $1 AND table_name = $2 AND row_id = $3`, [baseId, table, id]);
+        await sql.unsafe(`DELETE FROM ${self.ms("base_search")} WHERE base_id = $1 AND table_name = $2 AND row_id = $3`, [baseId, table, id]);
+        const [row] = await sql.unsafe(
+          `DELETE FROM ${self.ms("base_data")} WHERE base_id = $1 AND table_name = $2 AND id = $3 RETURNING id`,
+          [baseId, table, id]
+        );
+        return !!row;
+      },
+      // ── Query ────────────────────────────────────────────
+      async query(baseId, table, opts) {
+        await self.ensureMigrated(sql);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        const limit = Math.min(opts?.limit ?? DEFAULT_LIMIT2, MAX_LIMIT2);
+        const offset = opts?.offset ?? 0;
+        const sortCol = opts?.sort ? colMap.find((m) => m.field_name === opts.sort)?.physical || opts.sort : "created_at";
+        const sortOrder = opts?.order === "desc" ? "DESC" : "ASC";
+        const conditions = ["base_id = $1", "table_name = $2"];
+        const values = [baseId, table];
+        if (opts?.filter) {
+          const { conditions: fc, values: fv } = self.buildFilter(colMap, opts.filter, values.length + 1);
+          conditions.push(...fc);
+          values.push(...fv);
+        }
+        const where = conditions.join(" AND ");
+        const paramIdx = values.length + 1;
+        const rows = await sql.unsafe(`
+          SELECT * FROM ${self.ms("base_data")}
+          WHERE ${where}
+          ORDER BY ${q(sortCol)} ${sortOrder}
+          LIMIT $${paramIdx} OFFSET $${paramIdx + 1}
+        `, [...values, limit, offset]);
+        const result = rows.map((r) => self.reconstructRow(colMap, r));
+        if (opts?.include && opts.include.length > 0) {
+          const relMap = {};
+          for (const inc of opts.include) {
+            relMap[inc] = /* @__PURE__ */ new Set();
+          }
+          for (const row of result) {
+            for (const inc of opts.include) {
+              const val = row[inc];
+              if (val && typeof val === "string") relMap[inc].add(val);
+            }
+          }
+          for (const inc of opts.include) {
+            const mapping = colMap.find((m) => m.field_name === inc);
+            if (!mapping || !mapping.field_type.startsWith("relation")) continue;
+            const ids = [...relMap[inc]];
+            if (ids.length === 0) continue;
+          }
+        }
+        return result;
+      },
+      // ── Vector similarity search ─────────────────────────
+      async similaritySearch(baseId, table, field, vector, opts) {
+        await self.ensureMigrated(sql);
+        if (!self.hasVector) throw new Error("pgvector extension is not installed");
+        const limit = opts?.limit ?? 10;
+        const rows = await sql.unsafe(`
+          SELECT bd.*, bv.embedding <=> $1::vector AS distance
+          FROM ${self.ms("base_vectors")} bv
+          JOIN ${self.ms("base_data")} bd ON bd.id = bv.row_id
+          WHERE bv.base_id = $2 AND bv.table_name = $3 AND bv.field_name = $4
+          ORDER BY distance ASC
+          LIMIT $5
+        `, [JSON.stringify(vector), baseId, table, field, limit]);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        return rows.map((r) => ({
+          ...self.reconstructRow(colMap, r),
+          distance: r.distance
+        }));
+      },
+      // ── Full-text search ─────────────────────────────────
+      async search(baseId, table, field, query, opts) {
+        await self.ensureMigrated(sql);
+        const limit = opts?.limit ?? 10;
+        const offset = opts?.offset ?? 0;
+        const rows = await sql.unsafe(`
+          SELECT bd.*,
+                 ts_rank(bs.tsv, plainto_tsquery('simple', $1)) AS rank,
+                 ts_headline('simple', bs.content, plainto_tsquery('simple', $1),
+                   'StartSel=<mark>, StopSel=</mark>, MaxWords=50, MinWords=20') AS headline
+          FROM ${self.ms("base_search")} bs
+          JOIN ${self.ms("base_data")} bd ON bd.id = bs.row_id
+          WHERE bs.base_id = $2 AND bs.table_name = $3 AND bs.field_name = $4
+            AND bs.tsv @@ plainto_tsquery('simple', $1)
+          ORDER BY rank DESC
+          LIMIT $5 OFFSET $6
+        `, [query, baseId, table, field, limit, offset]);
+        const colMap = await self.getColumnMap(sql, baseId, table);
+        return rows.map((r) => ({
+          ...self.reconstructRow(colMap, r),
+          rank: r.rank,
+          headline: r.headline
+        }));
+      }
+    };
+  }
+  // ── Middleware ─────────────────────────────────────────────
+  async middleware(req, ctx, next) {
+    ctx.base = this.bind(ctx);
+    return next(req, ctx);
+  }
+};
+
+// src/base/index.ts
+function base(opts) {
+  const module = new Base(opts);
+  const mw = ((req, ctx, next) => {
+    return module.middleware(req, ctx, next);
+  });
+  mw.__meta = { injects: ["base"], depends: ["sql", "user"] };
+  return mw;
+}
+
+// src/cms/module.ts
+var DEFAULT_LIMIT3 = 20;
+var MAX_LIMIT3 = 100;
+function slugify2(text) {
+  return text.toLowerCase().replace(/[^\w\s-]/g, "").replace(/[\s_]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 200) || "untitled";
+}
+function getSql3(ctx) {
+  const sql = ctx.sql;
+  if (!sql) throw new Error("cms() requires postgres() middleware");
+  return sql;
+}
+function toContent(row) {
+  return {
+    id: row.id,
+    slug: row.slug,
+    type: row.type,
+    parent_id: row.parent_id,
+    title: row.title,
+    body: row.body,
+    excerpt: row.excerpt,
+    cover_image: row.cover_image,
+    status: row.status,
+    author_id: row.author_id,
+    author_name: row.author_name,
+    published_at: row.published_at,
+    created_at: row.created_at,
+    updated_at: row.updated_at,
+    tags: row.tags ? row.tags : void 0
+  };
+}
+function toTag(row) {
+  return { id: row.id, name: row.name, slug: row.slug };
+}
+function toTagWithCount(row) {
+  return { ...toTag(row), content_count: row.content_count };
+}
+function currentUserId2(ctx) {
+  const u = ctx.user;
+  if (!u?.id) throw new Error("cms() requires user() middleware \u2014 ctx.user is missing");
+  return u.id;
+}
+function requireAdmin(ctx) {
+  const u = ctx.user;
+  if (!u) throw new Error("Authentication required");
+  const role = u.role;
+  if (role !== "admin") throw new Error("Admin role required");
+}
+var CMS = class {
+  migrated = false;
+  prefix;
+  usersTable;
+  constructor(opts) {
+    this.prefix = opts?.tablePrefix ?? "";
+    this.usersTable = opts?.usersTable ?? "users";
+  }
+  q(name) {
+    return `"${this.prefix}${name}"`;
+  }
+  // ── Migration ──────────────────────────────────────────────
+  async migrate(sql) {
+    if (this.migrated) return;
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("contents")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        slug        TEXT NOT NULL,
+        type        TEXT NOT NULL DEFAULT 'post',
+        parent_id   UUID REFERENCES ${this.q("contents")}(id) ON DELETE SET NULL,
+        title       TEXT NOT NULL,
+        body        TEXT NOT NULL DEFAULT '',
+        excerpt     TEXT,
+        cover_image TEXT,
+        status      TEXT NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived')),
+        author_id   UUID NOT NULL,
+        published_at TIMESTAMPTZ,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE UNIQUE INDEX IF NOT EXISTS ${this.q("contents_slug_type_idx")}
+        ON ${this.q("contents")} (slug, type)
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${this.q("contents_type_status_idx")}
+        ON ${this.q("contents")} (type, status, created_at DESC)
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS ${this.q("contents_parent_idx")}
+        ON ${this.q("contents")} (parent_id)
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("tags")} (
+        id    UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        name  TEXT NOT NULL UNIQUE,
+        slug  TEXT NOT NULL UNIQUE
+      )
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.q("contents_tags")} (
+        content_id UUID NOT NULL REFERENCES ${this.q("contents")}(id) ON DELETE CASCADE,
+        tag_id     UUID NOT NULL REFERENCES ${this.q("tags")}(id) ON DELETE CASCADE,
+        PRIMARY KEY (content_id, tag_id)
+      )
+    `);
+    this.migrated = true;
+  }
+  async ensureMigrated(sql) {
+    if (!this.migrated) await this.migrate(sql);
+  }
+  // ── Per-request bound API ──────────────────────────────────
+  bind(ctx) {
+    const self = this;
+    const sql = getSql3(ctx);
+    if (!this.migrated) {
+      this.migrate(sql).catch(() => {
+      });
+    }
+    async function fetchTags(contentIds) {
+      if (contentIds.length === 0) return /* @__PURE__ */ new Map();
+      const rows = await sql.unsafe(`
+        SELECT ct.content_id, t.id, t.name, t.slug
+        FROM ${self.q("contents_tags")} ct
+        JOIN ${self.q("tags")} t ON t.id = ct.tag_id
+        WHERE ct.content_id = ANY($1::uuid[])
+        ORDER BY t.name
+      `, [contentIds]);
+      const map = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const cid = row.content_id;
+        if (!map.has(cid)) map.set(cid, []);
+        map.get(cid).push(toTag(row));
+      }
+      return map;
+    }
+    async function attachTags(contents) {
+      if (contents.length === 0) return contents;
+      const tags = await fetchTags(contents.map((c) => c.id));
+      for (const c of contents) {
+        const t = tags.get(c.id);
+        if (t) c.tags = t;
+      }
+      return contents;
+    }
+    async function updateContentTags(contentId, tagNames) {
+      await sql.unsafe(`DELETE FROM ${self.q("contents_tags")} WHERE content_id = $1`, [contentId]);
+      if (tagNames.length === 0) return;
+      const tagRecords = [];
+      for (const name of tagNames) {
+        const slug = slugify2(name);
+        const [tag] = await sql.unsafe(`
+          INSERT INTO ${self.q("tags")} (name, slug) VALUES ($1, $2)
+          ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name
+          RETURNING *
+        `, [name, slug]);
+        if (tag) tagRecords.push(toTag(tag));
+      }
+      if (tagRecords.length > 0) {
+        const values = tagRecords.map((_, i) => `($1, $${i + 2})`).join(", ");
+        await sql.unsafe(`
+          INSERT INTO ${self.q("contents_tags")} (content_id, tag_id)
+          VALUES ${values}
+          ON CONFLICT DO NOTHING
+        `, [contentId, ...tagRecords.map((t) => t.id)]);
+      }
+    }
+    return {
+      // ── List ─────────────────────────────────────────────
+      async list(opts) {
+        await self.ensureMigrated(sql);
+        const me = ctx.user;
+        const isAdmin = me?.role === "admin";
+        const limit = Math.min(opts?.limit ?? DEFAULT_LIMIT3, MAX_LIMIT3);
+        const conditions = [];
+        const values = [];
+        let idx = 1;
+        if (!isAdmin) {
+          conditions.push(`c.status = 'published'`);
+        } else if (opts?.status) {
+          conditions.push(`c.status = $${idx++}`);
+          values.push(opts.status);
+        }
+        if (opts?.type) {
+          conditions.push(`c.type = $${idx++}`);
+          values.push(opts.type);
+        }
+        if (opts?.tag) {
+          conditions.push(`EXISTS (SELECT 1 FROM ${self.q("contents_tags")} ct
+            JOIN ${self.q("tags")} t ON t.id = ct.tag_id
+            WHERE ct.content_id = c.id AND t.slug = $${idx})`);
+          values.push(opts.tag);
+          idx++;
+        }
+        if (opts?.author_id) {
+          conditions.push(`c.author_id = $${idx++}`);
+          values.push(opts.author_id);
+        }
+        if (opts?.parent_id !== void 0) {
+          if (opts.parent_id === null) {
+            conditions.push("c.parent_id IS NULL");
+          } else {
+            conditions.push(`c.parent_id = $${idx++}`);
+            values.push(opts.parent_id);
+          }
+        }
+        if (opts?.before) {
+          const [cursor] = await sql.unsafe(
+            `SELECT created_at FROM ${self.q("contents")} WHERE id = $1`,
+            [opts.before]
+          );
+          if (cursor) {
+            conditions.push(`c.created_at < $${idx++}`);
+            values.push(cursor.created_at);
+          }
+        }
+        const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const rows = await sql.unsafe(`
+          SELECT c.*, (SELECT u.name FROM "${self.usersTable}" u WHERE u.id = c.author_id) AS author_name
+          FROM ${self.q("contents")} c
+          ${where}
+          ORDER BY c.created_at DESC
+          LIMIT $${idx}
+        `, [...values, limit]);
+        const contents = rows.map(toContent);
+        return attachTags(contents);
+      },
+      // ── Get ──────────────────────────────────────────────
+      async get(slug) {
+        await self.ensureMigrated(sql);
+        const me = ctx.user;
+        const isAdmin = me?.role === "admin";
+        const [row] = await sql.unsafe(`
+          SELECT c.*, (SELECT u.name FROM "${self.usersTable}" u WHERE u.id = c.author_id) AS author_name
+          FROM ${self.q("contents")} c
+          WHERE c.slug = $1 ${isAdmin ? "" : "AND c.status = 'published'"}
+          LIMIT 1
+        `, [slug]);
+        if (!row) return null;
+        const content = toContent(row);
+        const tagged = await attachTags([content]);
+        return tagged[0];
+      },
+      async getById(id) {
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(`
+          SELECT c.*, (SELECT u.name FROM "${self.usersTable}" u WHERE u.id = c.author_id) AS author_name
+          FROM ${self.q("contents")} c
+          WHERE c.id = $1
+          LIMIT 1
+        `, [id]);
+        if (!row) return null;
+        const content = toContent(row);
+        const tagged = await attachTags([content]);
+        return tagged[0];
+      },
+      // ── Create ───────────────────────────────────────────
+      async create(input) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const slug = input.slug || slugify2(input.title);
+        const status = input.status || "draft";
+        const authorId = currentUserId2(ctx);
+        const parentId = input.parent_id || null;
+        const slugFinal = await self._uniqueSlug(sql, slug, input.type);
+        const [row] = await sql.unsafe(`
+          INSERT INTO ${self.q("contents")} (slug, type, parent_id, title, body, excerpt, cover_image, status, author_id)
+          VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
+          RETURNING *
+        `, [
+          slugFinal,
+          input.type,
+          parentId,
+          input.title,
+          input.body,
+          input.excerpt ?? null,
+          input.cover_image ?? null,
+          status,
+          authorId
+        ]);
+        const content = toContent(row);
+        content.author_name = ctx.user ? ctx.user.name : void 0;
+        if (input.tags && input.tags.length > 0) {
+          await updateContentTags(content.id, input.tags);
+          content.tags = await (async () => {
+            const map = await fetchTags([content.id]);
+            return map.get(content.id) || [];
+          })();
+        }
+        if (status === "published") {
+          await sql.unsafe(`UPDATE ${self.q("contents")} SET published_at = NOW() WHERE id = $1`, [content.id]);
+          content.published_at = /* @__PURE__ */ new Date();
+        }
+        return content;
+      },
+      // ── Update ───────────────────────────────────────────
+      async update(id, input) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const sets = [];
+        const values = [];
+        let idx = 1;
+        if (input.slug !== void 0) {
+          sets.push(`slug = $${idx++}`);
+          values.push(input.slug);
+        }
+        if (input.type !== void 0) {
+          sets.push(`type = $${idx++}`);
+          values.push(input.type);
+        }
+        if (input.title !== void 0) {
+          sets.push(`title = $${idx++}`);
+          values.push(input.title);
+        }
+        if (input.body !== void 0) {
+          sets.push(`body = $${idx++}`);
+          values.push(input.body);
+        }
+        if (input.excerpt !== void 0) {
+          sets.push(`excerpt = $${idx++}`);
+          values.push(input.excerpt);
+        }
+        if (input.cover_image !== void 0) {
+          sets.push(`cover_image = $${idx++}`);
+          values.push(input.cover_image);
+        }
+        if (input.status !== void 0) {
+          sets.push(`status = $${idx++}`);
+          values.push(input.status);
+        }
+        if (input.parent_id !== void 0) {
+          sets.push(`parent_id = $${idx++}`);
+          values.push(input.parent_id);
+        }
+        let row;
+        if (sets.length > 0) {
+          sets.push("updated_at = NOW()");
+          values.push(id);
+          [row] = await sql.unsafe(`
+            UPDATE ${self.q("contents")} SET ${sets.join(", ")} WHERE id = $${idx} RETURNING *
+          `, values);
+          if (!row) return null;
+        } else {
+          ;
+          [row] = await sql.unsafe(
+            `SELECT * FROM ${self.q("contents")} WHERE id = $1 LIMIT 1`,
+            [id]
+          );
+          if (!row) return null;
+          if (input.tags !== void 0) {
+            await sql.unsafe(`UPDATE ${self.q("contents")} SET updated_at = NOW() WHERE id = $1`, [id]);
+          }
+        }
+        if (input.tags !== void 0) {
+          await updateContentTags(id, input.tags);
+        }
+        if (input.status === "published") {
+          await sql.unsafe(`UPDATE ${self.q("contents")} SET published_at = COALESCE(published_at, NOW()) WHERE id = $1`, [id]);
+        }
+        const content = toContent(row);
+        const tagged = await attachTags([content]);
+        return tagged[0];
+      },
+      // ── Delete ───────────────────────────────────────────
+      async delete(id) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `DELETE FROM ${self.q("contents")} WHERE id = $1 RETURNING id`,
+          [id]
+        );
+        return !!row;
+      },
+      // ── Publish / Unpublish ─────────────────────────────
+      async publish(id) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(`
+          UPDATE ${self.q("contents")}
+          SET status = 'published', published_at = COALESCE(published_at, NOW()), updated_at = NOW()
+          WHERE id = $1 RETURNING *
+        `, [id]);
+        if (!row) return null;
+        const content = toContent(row);
+        const tagged = await attachTags([content]);
+        return tagged[0];
+      },
+      async unpublish(id) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(`
+          UPDATE ${self.q("contents")}
+          SET status = 'draft', updated_at = NOW()
+          WHERE id = $1 RETURNING *
+        `, [id]);
+        if (!row) return null;
+        const content = toContent(row);
+        const tagged = await attachTags([content]);
+        return tagged[0];
+      },
+      // ── Tags ─────────────────────────────────────────────
+      async listTags() {
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(`
+          SELECT t.*, COUNT(ct.content_id)::INT AS content_count
+          FROM ${self.q("tags")} t
+          LEFT JOIN ${self.q("contents_tags")} ct ON ct.tag_id = t.id
+          GROUP BY t.id
+          ORDER BY t.name
+        `);
+        return rows.map(toTagWithCount);
+      },
+      async createTag(name) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const slug = slugify2(name);
+        const [row] = await sql.unsafe(`
+          INSERT INTO ${self.q("tags")} (name, slug) VALUES ($1, $2)
+          ON CONFLICT (slug) DO UPDATE SET name = EXCLUDED.name
+          RETURNING *
+        `, [name, slug]);
+        return toTag(row);
+      },
+      async deleteTag(id) {
+        requireAdmin(ctx);
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `DELETE FROM ${self.q("tags")} WHERE id = $1 RETURNING id`,
+          [id]
+        );
+        return !!row;
+      }
+    };
+  }
+  // ── Internal ──────────────────────────────────────────────
+  async _uniqueSlug(sql, slug, type) {
+    const [existing] = await sql.unsafe(
+      `SELECT id FROM ${this.q("contents")} WHERE slug = $1 AND type = $2 LIMIT 1`,
+      [slug, type]
+    );
+    if (!existing) return slug;
+    for (let i = 2; i < 100; i++) {
+      const candidate = `${slug}-${i}`;
+      const [found] = await sql.unsafe(
+        `SELECT id FROM ${this.q("contents")} WHERE slug = $1 AND type = $2 LIMIT 1`,
+        [candidate, type]
+      );
+      if (!found) return candidate;
+    }
+    return `${slug}-${Date.now()}`;
+  }
+  // ── Middleware ─────────────────────────────────────────────
+  async middleware(req, ctx, next) {
+    ctx.cms = this.bind(ctx);
+    return next(req, ctx);
+  }
+};
+
+// src/cms/index.ts
+function cms(opts) {
+  const module = new CMS(opts);
+  const mw = ((req, ctx, next) => {
+    return module.middleware(req, ctx, next);
+  });
+  mw.__meta = { injects: ["cms"], depends: ["sql", "user"] };
+  return mw;
+}
+
+// src/kb/module.ts
+var DEFAULT_DIMENSIONS = 1536;
+var DEFAULT_CHUNK_SIZE = 512;
+var DEFAULT_CHUNK_OVERLAP = 64;
+var DEFAULT_TOP_K = 5;
+async function dashscopeEmbed(text) {
+  const apiKey = process.env.DASHSCOPE_API_KEY;
+  if (!apiKey) throw new Error(
+    "DASHSCOPE_API_KEY not set. Provide an embedding function in kb() options, or set the DASHSCOPE_API_KEY environment variable."
+  );
+  const baseURL = process.env.DASHSCOPE_API_URL || "https://dashscope.aliyuncs.com/compatible-mode/v1";
+  const res = await fetch(`${baseURL}/embeddings`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: "text-embedding-v4",
+      input: text,
+      dimensions: DEFAULT_DIMENSIONS
+    })
+  });
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`DashScope embedding error (${res.status}): ${body}`);
+  }
+  const data = await res.json();
+  return data.data[0].embedding;
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3.5);
+}
+function splitIntoChunks(text, chunkSize, overlap) {
+  const paragraphs = text.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+  const chunks = [];
+  let current = "";
+  for (const para of paragraphs) {
+    if (estimateTokens(para) > chunkSize) {
+      if (current) {
+        chunks.push(current.trim());
+        current = "";
+      }
+      const sentences = para.match(/[^.!?]+[.!?]+/g) || [para];
+      let sub = "";
+      for (const sent of sentences) {
+        const combined2 = sub ? `${sub} ${sent}` : sent;
+        if (estimateTokens(combined2) > chunkSize) {
+          if (sub) chunks.push(sub.trim());
+          sub = sent;
+        } else {
+          sub = combined2;
+        }
+      }
+      if (sub) current = sub;
+      continue;
+    }
+    const combined = current ? `${current}
+
+${para}` : para;
+    if (estimateTokens(combined) > chunkSize) {
+      chunks.push(current.trim());
+      current = para;
+    } else {
+      current = combined;
+    }
+  }
+  if (current.trim()) {
+    chunks.push(current.trim());
+  }
+  if (overlap > 0 && chunks.length > 1) {
+    for (let i = 1; i < chunks.length; i++) {
+      const prev = chunks[i - 1];
+      const prevWords = prev.split(/\s+/);
+      const overlapWords = [];
+      let overlapTokens = 0;
+      for (let j = prevWords.length - 1; j >= 0 && overlapTokens < overlap; j--) {
+        overlapWords.unshift(prevWords[j]);
+        overlapTokens += Math.ceil(prevWords[j].length / 3.5);
+      }
+      if (overlapWords.length > 0) {
+        chunks[i] = overlapWords.join(" ") + "\n\n" + chunks[i];
+      }
+    }
+  }
+  return chunks;
+}
+function getSql4(ctx) {
+  const sql = ctx.sql;
+  if (!sql) throw new Error("kb() requires postgres() middleware");
+  return sql;
+}
+function toDocument(row) {
+  return {
+    id: row.id,
+    title: row.title,
+    source: row.source,
+    metadata: row.metadata || {},
+    chunk_count: row.chunk_count,
+    created_at: row.created_at,
+    updated_at: row.updated_at
+  };
+}
+function toChunk(row) {
+  return {
+    id: row.id,
+    document_id: row.document_id,
+    content: row.content,
+    chunk_index: row.chunk_index,
+    tokens: row.tokens,
+    created_at: row.created_at
+  };
+}
+var KB = class {
+  migrated = false;
+  embedFn;
+  dimensions;
+  chunkSize;
+  chunkOverlap;
+  constructor(opts) {
+    this.embedFn = opts?.embed ?? dashscopeEmbed;
+    this.dimensions = opts?.dimensions ?? DEFAULT_DIMENSIONS;
+    this.chunkSize = opts?.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    this.chunkOverlap = opts?.chunkOverlap ?? DEFAULT_CHUNK_OVERLAP;
+  }
+  ms(name) {
+    return `"public"."${name}"`;
+  }
+  // ── Migration ──────────────────────────────────────────────
+  async migrate(sql) {
+    if (this.migrated) return;
+    await sql.unsafe("CREATE EXTENSION IF NOT EXISTS vector");
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.ms("kb_documents")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        title       TEXT NOT NULL,
+        source      TEXT,
+        metadata    JSONB NOT NULL DEFAULT '{}'::jsonb,
+        chunk_count INT NOT NULL DEFAULT 0,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE TABLE IF NOT EXISTS ${this.ms("kb_chunks")} (
+        id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        document_id UUID REFERENCES ${this.ms("kb_documents")}(id) ON DELETE CASCADE,
+        content     TEXT NOT NULL,
+        chunk_index INT NOT NULL,
+        embedding   VECTOR(${this.dimensions}) NOT NULL,
+        tokens      INT NOT NULL DEFAULT 0,
+        created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      )
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS kb_chunks_doc_idx
+        ON ${this.ms("kb_chunks")} (document_id)
+    `);
+    await sql.unsafe(`
+      CREATE INDEX IF NOT EXISTS kb_chunks_content_idx
+        ON ${this.ms("kb_chunks")} USING GIN (to_tsvector('simple', content))
+    `);
+    this.migrated = true;
+  }
+  async ensureMigrated(sql) {
+    if (!this.migrated) await this.migrate(sql);
+  }
+  // ── Per-request bound API ──────────────────────────────────
+  bind(ctx) {
+    const self = this;
+    const sql = getSql4(ctx);
+    if (!this.migrated) {
+      this.migrate(sql).catch(() => {
+      });
+    }
+    return {
+      // ── Import text ─────────────────────────────────────
+      async importText(title, text, opts) {
+        await self.ensureMigrated(sql);
+        const chunkSize = opts?.chunkSize ?? self.chunkSize;
+        const overlap = opts?.chunkOverlap ?? self.chunkOverlap;
+        const chunks = splitIntoChunks(text, chunkSize, overlap);
+        if (chunks.length === 0) throw new Error("No content to import");
+        const meta = opts?.metadata ?? {};
+        const [docRow] = await sql.unsafe(
+          `
+          INSERT INTO ${self.ms("kb_documents")} (title, source, metadata)
+          VALUES ($1, $2, $3) RETURNING *
+        `,
+          [title, opts?.source ?? null, meta]
+        );
+        const chunkRows = [];
+        for (let i = 0; i < chunks.length; i++) {
+          const content = chunks[i];
+          const tokens = estimateTokens(content);
+          const [chunkRow] = await sql.unsafe(`
+            INSERT INTO ${self.ms("kb_chunks")} (document_id, content, chunk_index, embedding, tokens)
+            VALUES ($1, $2, $3, $4::vector, $5) RETURNING *
+          `, [
+            docRow.id,
+            content,
+            i,
+            JSON.stringify(await self.embedFn(content)),
+            tokens
+          ]);
+          chunkRows.push(toChunk(chunkRow));
+        }
+        await sql.unsafe(
+          `UPDATE ${self.ms("kb_documents")} SET chunk_count = $1 WHERE id = $2`,
+          [chunks.length, docRow.id]
+        );
+        const doc = toDocument(docRow);
+        doc.chunk_count = chunks.length;
+        return { document: doc, chunks: chunkRows };
+      },
+      // ── Import documents ─────────────────────────────────
+      async importDocuments(docs) {
+        const results = [];
+        for (const doc of docs) {
+          const { document } = await this.importText(doc.title, doc.content, {
+            source: doc.source,
+            metadata: doc.metadata,
+            chunkSize: doc.chunkSize,
+            chunkOverlap: doc.chunkOverlap
+          });
+          results.push(document);
+        }
+        return results;
+      },
+      // ── Search ─────────────────────────────────────────
+      async search(query, opts) {
+        await self.ensureMigrated(sql);
+        const limit = Math.min(opts?.limit ?? DEFAULT_TOP_K, 50);
+        const minScore = opts?.minScore ?? 0;
+        const queryVec = await self.embedFn(query);
+        const filterJoin = opts?.filter ? Object.entries(opts.filter).map(
+          ([k, v]) => `AND d.metadata @> '${JSON.stringify({ [k]: v })}'::jsonb`
+        ).join(" ") : "";
+        const rows = await sql.unsafe(`
+          SELECT
+            c.id AS chunk_id,
+            c.document_id,
+            c.content,
+            1 - (c.embedding <=> $1::vector) AS score,
+            d.title,
+            d.source
+          FROM ${self.ms("kb_chunks")} c
+          LEFT JOIN ${self.ms("kb_documents")} d ON d.id = c.document_id
+          WHERE (1 - (c.embedding <=> $1::vector)) >= $2
+            ${filterJoin}
+          ORDER BY score DESC
+          LIMIT $3
+        `, [JSON.stringify(queryVec), minScore, limit]);
+        return rows.map((r) => ({
+          chunk_id: r.chunk_id,
+          document_id: r.document_id,
+          content: r.content,
+          score: r.score,
+          title: r.title,
+          source: r.source
+        }));
+      },
+      // ── List documents ───────────────────────────────────
+      async list() {
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(
+          `SELECT * FROM ${self.ms("kb_documents")} ORDER BY created_at DESC`
+        );
+        return rows.map(toDocument);
+      },
+      // ── Get document ─────────────────────────────────────
+      async get(id) {
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `SELECT * FROM ${self.ms("kb_documents")} WHERE id = $1 LIMIT 1`,
+          [id]
+        );
+        return row ? toDocument(row) : null;
+      },
+      // ── Get chunks ───────────────────────────────────────
+      async getChunks(documentId) {
+        await self.ensureMigrated(sql);
+        const rows = await sql.unsafe(
+          `SELECT * FROM ${self.ms("kb_chunks")} WHERE document_id = $1 ORDER BY chunk_index`,
+          [documentId]
+        );
+        return rows.map(toChunk);
+      },
+      // ── Delete document ──────────────────────────────────
+      async delete(id) {
+        await self.ensureMigrated(sql);
+        const [row] = await sql.unsafe(
+          `DELETE FROM ${self.ms("kb_documents")} WHERE id = $1 RETURNING id`,
+          [id]
+        );
+        return !!row;
+      }
+    };
+  }
+  // ── Middleware ─────────────────────────────────────────────
+  async middleware(req, ctx, next) {
+    ctx.kb = this.bind(ctx);
+    return next(req, ctx);
+  }
+};
+
+// src/kb/index.ts
+function kb(opts) {
+  const module = new KB(opts);
+  const mw = ((req, ctx, next) => {
+    return module.middleware(req, ctx, next);
+  });
+  mw.__meta = { injects: ["kb"], depends: ["sql"] };
+  return mw;
+}
 export {
+  Base,
+  CMS,
   DEFAULT_MAX_BODY,
   ErrorBoundary,
   HttpError,
+  KB,
   Link,
   MIGRATIONS_TABLE,
+  Messager,
   Router,
   ServerDataContext,
+  UserModule,
   agent,
   ai,
-  auth,
+  base,
+  cms,
   compress,
   cors,
   createHub,
@@ -3096,13 +5245,16 @@ export {
   esbuildDev,
   graphql,
   helmet,
+  kb,
   logger,
+  messager,
   postgres,
   queue,
   rateLimit,
   react,
   reactRouter,
   redis,
+  requireRole,
   runWithTrace,
   sandbox,
   serve,
@@ -3111,5 +5263,6 @@ export {
   trace,
   traceElapsed,
   upload,
-  useServerData
+  useServerData,
+  user
 };