weifuwu 0.13.0 → 0.14.0

package/dist/index.js

@@ -2081,11 +2081,11 @@ function evaluateExpression(expr, ctx) {
   let bestIdx = -1;
   let bestOp = null;
   let bestFn = null;
-  for (const { op, fn } of operators) {
-    const idx = expr.indexOf(op);
+  for (const { op: op2, fn } of operators) {
+    const idx = expr.indexOf(op2);
     if (idx > 0 && (bestIdx === -1 || idx < bestIdx)) {
       bestIdx = idx;
-      bestOp = op;
+      bestOp = op2;
       bestFn = fn;
     }
   }
@@ -2363,6 +2363,9 @@ function textArray(name) {
 function vector(name, dims) {
   return col(name, `vector(${dims})`);
 }
+function partitionBy(type, column) {
+  return { type: type.toUpperCase(), column };
+}
 function toDDL(col2) {
   const parts = [`"${col2.name}"`, col2.sqlType];
   if (col2.isPrimaryKey) parts.push("PRIMARY KEY");
@@ -2376,6 +2379,44 @@ function toDDL(col2) {
   return parts.join(" ");
 }
 
+// postgres/schema/where.ts
+function op(col2, sqlOp, val) {
+  return new SQL([`"${col2}" ${sqlOp} `, ""], [val]);
+}
+function eq(col2, val) {
+  return op(col2, "=", val);
+}
+function gte(col2, val) {
+  return op(col2, ">=", val);
+}
+function lt(col2, val) {
+  return op(col2, "<", val);
+}
+function contains(col2, val) {
+  return new SQL([`"${col2}" @> `, ""], [val]);
+}
+function combine(conditions, joiner) {
+  if (conditions.length === 0) return new SQL([""], []);
+  const strings = ["("];
+  const values = [];
+  for (let i = 0; i < conditions.length; i++) {
+    if (i > 0) strings[strings.length - 1] += ` ${joiner} `;
+    const s = conditions[i];
+    for (let j = 0; j < s.strings.length; j++) {
+      strings[strings.length - 1] += s.strings[j];
+      if (j < s.values.length) {
+        strings.push("");
+        values.push(s.values[j]);
+      }
+    }
+  }
+  strings[strings.length - 1] += ")";
+  return new SQL(strings, values);
+}
+function and(...conditions) {
+  return combine(conditions, "AND");
+}
+
 // postgres/schema/table.ts
 var Table = class {
   tableName;
@@ -2390,18 +2431,21 @@ var Table = class {
       auto: col2.isAutoGenerate
     }));
   }
-  async create(sql2) {
+  async create(sql4, opts) {
     const colDDL = this.columns.map(toDDL);
-    const ddl = `CREATE TABLE IF NOT EXISTS "${this.tableName}" (
+    let ddl = `CREATE TABLE IF NOT EXISTS "${this.tableName}" (
   ${colDDL.join(",\n  ")}
 )`;
-    await sql2.unsafe(ddl);
+    if (opts?.partitionBy) {
+      ddl += ` PARTITION BY ${opts.partitionBy.type} ("${opts.partitionBy.column}")`;
+    }
+    await sql4.unsafe(ddl);
   }
-  async drop(sql2, opts) {
+  async drop(sql4, opts) {
     const cascade = opts?.cascade ? " CASCADE" : "";
-    await sql2.unsafe(`DROP TABLE IF EXISTS "${this.tableName}"${cascade}`);
+    await sql4.unsafe(`DROP TABLE IF EXISTS "${this.tableName}"${cascade}`);
   }
-  async createIndex(sql2, columns, opts) {
+  async createIndex(sql4, columns, opts) {
     const cols = Array.isArray(columns) ? columns : [columns];
     const name = `"${this.tableName}_${cols.join("_")}${opts?.unique ? "_uidx" : "_idx"}"`;
     const unique = opts?.unique ? "UNIQUE" : "";
@@ -2409,13 +2453,13 @@ var Table = class {
     const colList = cols.map((c) => opts?.desc ? `"${c}" DESC` : `"${c}"`).join(", ");
     const operator = opts?.operator ? ` ${opts.operator}` : "";
     const ddl = `CREATE ${unique} INDEX IF NOT EXISTS ${name} ON "${this.tableName}" ${using} (${colList}${operator})`.replace(/\s+/g, " ");
-    await sql2.unsafe(ddl);
+    await sql4.unsafe(ddl);
   }
-  async createUniqueIndex(sql2, columns) {
-    await this.createIndex(sql2, columns, { unique: true });
+  async createUniqueIndex(sql4, columns) {
+    await this.createIndex(sql4, columns, { unique: true });
   }
   // --- CRUD ---
-  async insert(sql2, data) {
+  async insert(sql4, data) {
     const filtered = {};
     for (const { prop, db, auto } of this.colEntries) {
       if (auto) continue;
@@ -2423,30 +2467,70 @@ var Table = class {
         filtered[db] = data[prop];
       }
     }
-    const [row] = await sql2`
-      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
+    const [row] = await sql4`
+      INSERT INTO ${sql4(this.tableName)} ${sql4(filtered)} RETURNING *
     `;
     return row;
   }
-  async findById(sql2, id2) {
-    const [row] = await sql2`
-      SELECT * FROM ${sql2(this.tableName)}
-      WHERE ${sql2("id")} = ${id2} LIMIT 1
+  async insertMany(sql4, data) {
+    const filtered = [];
+    for (const item of data) {
+      const row = {};
+      for (const { prop, db, auto } of this.colEntries) {
+        if (auto) continue;
+        if (prop in item) {
+          row[db] = item[prop];
+        }
+      }
+      filtered.push(row);
+    }
+    const rows = await sql4`
+      INSERT INTO ${sql4(this.tableName)} ${sql4(filtered)} RETURNING *
+    `;
+    return rows;
+  }
+  async read(sql4, id2) {
+    const [row] = await sql4`
+      SELECT * FROM ${sql4(this.tableName)}
+      WHERE ${sql4("id")} = ${id2} LIMIT 1
     `;
     return row ?? void 0;
   }
-  async find(sql2, where, opts) {
+  async readMany(sql4, where, opts) {
     const conditions = [];
     const values = [];
-    for (const [prop, value] of Object.entries(where || {})) {
-      if (value === void 0) continue;
-      const entry = this.colEntries.find((e) => e.prop === prop);
-      const db = entry ? entry.db : prop;
-      conditions.push(`"${db}" = $${conditions.length + 1}`);
-      values.push(value);
+    let w = where;
+    if (Array.isArray(w)) {
+      w = w.length > 0 ? and(...w) : void 0;
+    }
+    if (w instanceof SQL) {
+      let fragment = "";
+      for (let i = 0; i < w.strings.length; i++) {
+        fragment += w.strings[i];
+        if (i < w.values.length) {
+          fragment += `$${values.length + 1}`;
+          values.push(w.values[i]);
+        }
+      }
+      conditions.push(fragment);
+    } else {
+      for (const [prop, value] of Object.entries(w || {})) {
+        if (value === void 0) continue;
+        const entry = this.colEntries.find((e) => e.prop === prop);
+        const db = entry ? entry.db : prop;
+        conditions.push(`"${db}" = $${conditions.length + 1}`);
+        values.push(value);
+      }
+    }
+    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
+    const [countRow] = await sql4.unsafe(`SELECT COUNT(*) AS _total FROM "${this.tableName}"${whereClause}`, values);
+    const count = Number(countRow._total);
+    if (conditions.length === 0 && !opts?.orderBy && !opts?.limit && !opts?.offset && !opts?.select) {
+      const rows2 = await sql4`SELECT * FROM ${sql4(this.tableName)}`;
+      return { count, data: rows2 };
     }
-    let query = `SELECT * FROM "${this.tableName}"`;
-    if (conditions.length > 0) query += ` WHERE ${conditions.join(" AND ")}`;
+    const columns = opts?.select?.length ? opts.select.map((c) => `"${c}"`).join(", ") : "*";
+    let query = `SELECT ${columns} FROM "${this.tableName}"${whereClause}`;
     if (opts?.orderBy) {
       const orders = Object.entries(opts.orderBy).map(([prop, dir]) => {
         const entry = this.colEntries.find((e) => e.prop === prop);
@@ -2456,14 +2540,29 @@ var Table = class {
     }
     if (opts?.limit) query += ` LIMIT ${opts.limit}`;
     if (opts?.offset) query += ` OFFSET ${opts.offset}`;
-    if (conditions.length > 0 || opts?.orderBy || opts?.limit !== void 0 || opts?.offset !== void 0) {
-      const rows2 = await sql2.unsafe(query, values);
-      return rows2;
+    const rows = await sql4.unsafe(query, values);
+    return { count, data: rows };
+  }
+  async update(sql4, id2, data) {
+    const sets = [];
+    const setValues = [];
+    for (const { prop, db } of this.colEntries) {
+      if (prop in data && data[prop] !== void 0) {
+        const val = data[prop];
+        if (val instanceof SQL) {
+          sets.push(`"${db}" = ${val.toSQL()}`);
+        } else {
+          sets.push(`"${db}" = $${sets.length + 1}`);
+          setValues.push(val);
+        }
+      }
     }
-    const rows = await sql2`SELECT * FROM ${sql2(this.tableName)}`;
-    return rows;
+    if (sets.length === 0) return void 0;
+    const query = `UPDATE "${this.tableName}" AS t SET ${sets.join(", ")} FROM (SELECT ctid FROM "${this.tableName}" WHERE id = $${setValues.length + 1} LIMIT 1) AS sub WHERE t.ctid = sub.ctid RETURNING t.*`;
+    const rows = await sql4.unsafe(query, [...setValues, id2]);
+    return rows[0] ?? void 0;
   }
-  async update(sql2, where, data) {
+  async updateMany(sql4, where, data) {
     const sets = [];
     const setValues = [];
     for (const { prop, db } of this.colEntries) {
@@ -2486,12 +2585,14 @@ var Table = class {
       wConditions.push(`"${db}" = $${values.length + 1}`);
       values.push(value);
     }
-    if (sets.length === 0 || wConditions.length === 0) return void 0;
-    const query = `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE ${wConditions.join(" AND ")} RETURNING *`;
-    const rows = await sql2.unsafe(query, values);
-    return rows[0] ?? void 0;
+    if (sets.length === 0 || wConditions.length === 0) return 0;
+    const rows = await sql4.unsafe(
+      `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE ${wConditions.join(" AND ")} RETURNING 1`,
+      values
+    );
+    return rows.length;
   }
-  async delete(sql2, where) {
+  async deleteMany(sql4, where) {
     const conditions = [];
     const values = [];
     for (const [prop, value] of Object.entries(where)) {
@@ -2501,18 +2602,26 @@ var Table = class {
       conditions.push(`"${db}" = $${conditions.length + 1}`);
       values.push(value);
     }
-    if (conditions.length === 0) return false;
-    const query = `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`;
-    const rows = await sql2.unsafe(query, values);
-    return rows.length > 0;
+    if (conditions.length === 0) return 0;
+    const rows = await sql4.unsafe(
+      `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`,
+      values
+    );
+    return rows.length;
+  }
+  async delete(sql4, id2) {
+    const [row] = await sql4`
+      DELETE FROM ${sql4(this.tableName)} WHERE ${sql4("id")} = ${id2} RETURNING *
+    `;
+    return row ?? void 0;
   }
 };
 var BoundTable = class {
   inner;
   sql;
-  constructor(sql2, tableName, builders) {
+  constructor(sql4, tableName, builders) {
     this.inner = new Table(tableName, builders);
-    this.sql = sql2;
+    this.sql = sql4;
   }
   async create() {
     await this.inner.create(this.sql);
@@ -2529,17 +2638,26 @@ var BoundTable = class {
   async insert(data) {
     return await this.inner.insert(this.sql, data);
   }
-  async findById(id2) {
-    return await this.inner.findById(this.sql, id2);
+  async insertMany(data) {
+    return await this.inner.insertMany(this.sql, data);
+  }
+  async read(id2) {
+    return await this.inner.read(this.sql, id2);
+  }
+  async readMany(where, opts) {
+    return await this.inner.readMany(this.sql, where, opts);
+  }
+  async update(id2, data) {
+    return await this.inner.update(this.sql, id2, data);
   }
-  async find(where, opts) {
-    return await this.inner.find(this.sql, where, opts);
+  async updateMany(where, data) {
+    return await this.inner.updateMany(this.sql, where, data);
   }
-  async update(where, data) {
-    return await this.inner.update(this.sql, where, data);
+  async delete(id2) {
+    return await this.inner.delete(this.sql, id2);
   }
-  async delete(where) {
-    return await this.inner.delete(this.sql, where);
+  async deleteMany(where) {
+    return await this.inner.deleteMany(this.sql, where);
   }
 };
 function pgTable(tableName, builders) {
@@ -2555,7 +2673,7 @@ function postgres(opts) {
       "postgres: DATABASE_URL is not set. Pass a connection string or set the DATABASE_URL environment variable."
     );
   }
-  const sql2 = postgresFactory(connection, {
+  const sql4 = postgresFactory(connection, {
     max: options.max,
     ssl: options.ssl,
     idle_timeout: options.idle_timeout,
@@ -2563,24 +2681,24 @@ function postgres(opts) {
   });
   if (options.signal) {
     options.signal.addEventListener("abort", () => {
-      sql2.end();
+      sql4.end();
     }, { once: true });
   }
   const closeTimeout = options.closeTimeout ?? 5;
   const mw = ((req, ctx, next) => {
-    ctx.sql = sql2;
+    ctx.sql = sql4;
     return next(req, ctx);
   });
-  mw.sql = sql2;
+  mw.sql = sql4;
   mw.table = ((tableName, builders) => {
-    return new BoundTable(sql2, tableName, builders);
+    return new BoundTable(sql4, tableName, builders);
   });
   mw.migrate = async () => {
   };
   mw.transaction = (async (fn) => {
-    return await sql2.begin(fn);
+    return await sql4.begin(fn);
   });
-  mw.close = () => sql2.end({ timeout: closeTimeout });
+  mw.close = () => sql4.end({ timeout: closeTimeout });
   return mw;
 }
 
@@ -2894,7 +3012,7 @@ h2{color:#dc2626}.desc{color:#555}</style>
       }
     }
     await pg.sql`UPDATE "_oauth2_codes" SET "used" = TRUE WHERE "id" = ${stored.id}`;
-    const user2 = await users.findById(stored.user_id);
+    const user2 = await users.read(stored.user_id);
     if (!user2) {
       return Response.json({ error: "invalid_grant" }, { status: 400 });
     }
@@ -2982,7 +3100,7 @@ function user(options) {
   if (oauth2Enabled) {
     oauth2 = createOAuth2Server({ pg, users, jwtSecret: secret, expiresIn });
   }
-  async function migrate6() {
+  async function migrate7() {
     await migrate({ pg, usersTable: table, oauth2: oauth2Enabled });
   }
   function signToken(user2) {
@@ -2997,11 +3115,11 @@ function user(options) {
     return user2;
   }
   async function findByEmail(email) {
-    const rows = await users.find({ email });
+    const { data: rows } = await users.readMany({ email });
     return rows[0];
   }
   async function findById(id2) {
-    return await users.findById(id2);
+    return await users.read(id2);
   }
   async function register(data) {
     const { email, password, name } = RegisterSchema.parse(data);
@@ -3019,7 +3137,7 @@ function user(options) {
   }
   async function login(data) {
     const { email, password } = LoginSchema.parse(data);
-    const rows = await users.find({ email });
+    const { data: rows } = await users.readMany({ email });
     const row = rows[0];
     if (!row) {
       const err = new Error("Invalid email or password");
@@ -3101,7 +3219,7 @@ function user(options) {
   const mod = {
     router,
     middleware,
-    migrate: migrate6,
+    migrate: migrate7,
     register,
     login,
     verify,
@@ -3284,14 +3402,14 @@ function queue(opts) {
 
 // tenant/migrate.ts
 async function migrate2(opts) {
-  const { sql: sql2 } = opts;
-  await sql2.unsafe(`CREATE EXTENSION IF NOT EXISTS "vector"`);
+  const { sql: sql4 } = opts;
+  await sql4.unsafe(`CREATE EXTENSION IF NOT EXISTS "vector"`);
   const tenants = pgTable("_tenants", {
     id: text("id").primaryKey().default(sql`gen_random_uuid()`),
     name: text("name").notNull(),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await tenants.create(sql2);
+  await tenants.create(sql4);
   const members = pgTable("_tenant_members", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
@@ -3299,9 +3417,9 @@ async function migrate2(opts) {
     role: text("role").notNull().default("member"),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await members.create(sql2);
-  await members.createIndex(sql2, "user_id");
-  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_tenant_members_unique_idx" ON "_tenant_members" ("tenant_id", "user_id")`);
+  await members.create(sql4);
+  await members.createIndex(sql4, "user_id");
+  await sql4.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_tenant_members_unique_idx" ON "_tenant_members" ("tenant_id", "user_id")`);
   const tables = pgTable("_user_tables", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id").notNull().references("_tenants", "id", "cascade"),
@@ -3310,9 +3428,9 @@ async function migrate2(opts) {
     fields: jsonb("fields").notNull().default(sql`'[]'::jsonb`),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await tables.create(sql2);
-  await tables.createIndex(sql2, "tenant_id");
-  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_user_tables_unique_idx" ON "_user_tables" ("tenant_id", "slug")`);
+  await tables.create(sql4);
+  await tables.createIndex(sql4, "tenant_id");
+  await sql4.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_user_tables_unique_idx" ON "_user_tables" ("tenant_id", "slug")`);
 }
 
 // tenant/rest.ts
@@ -3506,8 +3624,8 @@ function zodType(field) {
   }
   return t;
 }
-async function getUserTable(sql2, tenantId, slug) {
-  const [row] = await sql2`
+async function getUserTable(sql4, tenantId, slug) {
+  const [row] = await sql4`
     SELECT * FROM "_user_tables"
     WHERE tenant_id = ${tenantId} AND slug = ${slug}
     LIMIT 1
@@ -3518,24 +3636,24 @@ function requireAdmin(ctx) {
   if (ctx.tenant?.role !== "admin") return Response.json({ error: "Forbidden" }, { status: 403 });
   return null;
 }
-function buildRouter(sql2, usersTable) {
+function buildRouter(sql4, usersTable) {
   const r = new Router();
   r.post("/sys/tenants", async (req, ctx) => {
     const { name } = await req.json();
     if (!name || typeof name !== "string") {
       return Response.json({ error: "name is required" }, { status: 400 });
     }
-    const [tenant2] = await sql2`
+    const [tenant2] = await sql4`
       INSERT INTO "_tenants" ("name") VALUES (${name}) RETURNING *
     `;
-    await sql2`
+    await sql4`
       INSERT INTO "_tenant_members" ("tenant_id", "user_id", "role")
       VALUES (${tenant2.id}, ${ctx.user.id}, 'admin')
     `;
     return Response.json(tenant2, { status: 201 });
   });
   r.get("/sys/tenants", async (_req, ctx) => {
-    const rows = await sql2`
+    const rows = await sql4`
       SELECT t.*, tm.role FROM "_tenants" t
       JOIN "_tenant_members" tm ON tm.tenant_id = t.id
       WHERE tm.user_id = ${ctx.user.id}
@@ -3546,16 +3664,16 @@ function buildRouter(sql2, usersTable) {
     const err = requireAdmin(ctx);
     if (err) return err;
     const { email, role = "member" } = await req.json();
-    const [user2] = await sql2`
-      SELECT id FROM ${sql2(usersTable)} WHERE "email" = ${email} LIMIT 1
+    const [user2] = await sql4`
+      SELECT id FROM ${sql4(usersTable)} WHERE "email" = ${email} LIMIT 1
     `;
     if (!user2) return Response.json({ error: "User not found" }, { status: 404 });
-    const [existing] = await sql2`
+    const [existing] = await sql4`
       SELECT id FROM "_tenant_members"
       WHERE tenant_id = ${ctx.tenant.id} AND user_id = ${user2.id} LIMIT 1
     `;
     if (existing) return Response.json({ error: "Already a member" }, { status: 409 });
-    await sql2`
+    await sql4`
       INSERT INTO "_tenant_members" ("tenant_id", "user_id", "role")
       VALUES (${ctx.tenant.id}, ${user2.id}, ${role})
     `;
@@ -3565,7 +3683,7 @@ function buildRouter(sql2, usersTable) {
     const err = requireAdmin(ctx);
     if (err) return err;
     const userId = parseInt(ctx.params.userId, 10);
-    await sql2`
+    await sql4`
       DELETE FROM "_tenant_members"
       WHERE tenant_id = ${ctx.tenant.id} AND user_id = ${userId}
     `;
@@ -3581,17 +3699,17 @@ function buildRouter(sql2, usersTable) {
     if (fieldErrs.length) {
       return Response.json({ error: "Invalid fields", details: fieldErrs }, { status: 400 });
     }
-    const [existing] = await sql2`
+    const [existing] = await sql4`
       SELECT id FROM "_user_tables"
       WHERE tenant_id = ${ctx.tenant.id} AND slug = ${body.slug} LIMIT 1
     `;
     if (existing) return Response.json({ error: "Table already exists" }, { status: 409 });
     const createSQL = createTableSQL(ctx.tenant.id, body.slug, body.fields);
-    await sql2.unsafe(createSQL);
+    await sql4.unsafe(createSQL);
     for (const stmt of createIndexesSQL(ctx.tenant.id, body.slug, body.fields)) {
-      await sql2.unsafe(stmt);
+      await sql4.unsafe(stmt);
     }
-    const [row] = await sql2`
+    const [row] = await sql4`
       INSERT INTO "_user_tables" ("tenant_id", "slug", "label", "fields")
       VALUES (${ctx.tenant.id}, ${body.slug}, ${body.label || ""}, ${body.fields})
       RETURNING *
@@ -3599,7 +3717,7 @@ function buildRouter(sql2, usersTable) {
     return Response.json(row, { status: 201 });
   });
   r.get("/sys/tables", async (_req, ctx) => {
-    const rows = await sql2`
+    const rows = await sql4`
       SELECT * FROM "_user_tables"
       WHERE tenant_id = ${ctx.tenant.id}
       ORDER BY created_at DESC
@@ -3607,7 +3725,7 @@ function buildRouter(sql2, usersTable) {
     return Response.json(rows);
   });
   r.get("/sys/tables/:slug", async (_req, ctx) => {
-    const table = await getUserTable(sql2, ctx.tenant.id, ctx.params.slug);
+    const table = await getUserTable(sql4, ctx.tenant.id, ctx.params.slug);
     if (!table) return Response.json({ error: "Table not found" }, { status: 404 });
     return Response.json(table);
   });
@@ -3618,15 +3736,15 @@ function buildRouter(sql2, usersTable) {
     if (!body.fields || !Array.isArray(body.fields)) {
       return Response.json({ error: "fields array required" }, { status: 400 });
     }
-    const table = await getUserTable(sql2, ctx.tenant.id, ctx.params.slug);
+    const table = await getUserTable(sql4, ctx.tenant.id, ctx.params.slug);
     if (!table) return Response.json({ error: "Table not found" }, { status: 404 });
     const existingNames = new Set(table.fields.map((f) => f.name));
     const newFields = body.fields.filter((f) => !existingNames.has(f.name));
     for (const f of newFields) {
-      await sql2.unsafe(addColumnSQL(ctx.tenant.id, ctx.params.slug, f));
+      await sql4.unsafe(addColumnSQL(ctx.tenant.id, ctx.params.slug, f));
     }
     const merged = [...table.fields, ...newFields];
-    await sql2`
+    await sql4`
       UPDATE "_user_tables"
       SET fields = ${merged}
       WHERE id = ${table.id}
@@ -3636,15 +3754,15 @@ function buildRouter(sql2, usersTable) {
   r.delete("/sys/tables/:slug", async (_req, ctx) => {
     const err = requireAdmin(ctx);
     if (err) return err;
-    await sql2.unsafe(dropTableSQL(ctx.tenant.id, ctx.params.slug));
-    await sql2`
+    await sql4.unsafe(dropTableSQL(ctx.tenant.id, ctx.params.slug));
+    await sql4`
       DELETE FROM "_user_tables"
       WHERE tenant_id = ${ctx.tenant.id} AND slug = ${ctx.params.slug}
     `;
     return Response.json({ ok: true });
   });
   async function resolveTable(ctx) {
-    return getUserTable(sql2, ctx.tenant.id, ctx.params["_slug"]);
+    return getUserTable(sql4, ctx.tenant.id, ctx.params["_slug"]);
   }
   function internalName(ctx) {
     return internalTableName(ctx.tenant.id, ctx.params["_slug"]);
@@ -3667,11 +3785,11 @@ function buildRouter(sql2, usersTable) {
       try {
         const parsed = JSON.parse(searchVector);
         const [rows2, countResult2] = await Promise.all([
-          sql2.unsafe(
+          sql4.unsafe(
             `SELECT *, "${searchField}" ${operator} $1::vector AS "_distance" FROM "${name2}" WHERE tenant_id = $2 ORDER BY "_distance" LIMIT $3 OFFSET $4`,
             [parsed, ctx.tenant.id, limit, offset]
           ),
-          sql2.unsafe(
+          sql4.unsafe(
             `SELECT count(*) as count FROM "${name2}" WHERE tenant_id = $1`,
             [ctx.tenant.id]
           )
@@ -3683,11 +3801,11 @@ function buildRouter(sql2, usersTable) {
     }
     const name = internalName(ctx);
     const [rows, countResult] = await Promise.all([
-      sql2.unsafe(
+      sql4.unsafe(
         `SELECT * FROM "${name}" WHERE tenant_id = $1 ORDER BY "${orderCol}" ${orderDir} LIMIT $2 OFFSET $3`,
         [ctx.tenant.id, limit, offset]
       ),
-      sql2.unsafe(
+      sql4.unsafe(
         `SELECT count(*) as count FROM "${name}" WHERE tenant_id = $1`,
         [ctx.tenant.id]
       )
@@ -3707,15 +3825,15 @@ function buildRouter(sql2, usersTable) {
     parsed.tenant_id = ctx.tenant.id;
     delete parsed.id;
     const name = internalName(ctx);
-    const [row] = await sql2`INSERT INTO ${sql2(name)} ${sql2(parsed)} RETURNING *`;
+    const [row] = await sql4`INSERT INTO ${sql4(name)} ${sql4(parsed)} RETURNING *`;
     return Response.json(row, { status: 201 });
   });
   r.get("/:_slug/:id", async (_req, ctx) => {
     const table = await resolveTable(ctx);
     if (!table) return Response.json({ error: "Table not found" }, { status: 404 });
     const name = internalName(ctx);
-    const [row] = await sql2`
-      SELECT * FROM ${sql2(name)}
+    const [row] = await sql4`
+      SELECT * FROM ${sql4(name)}
       WHERE id = ${parseInt(ctx.params.id, 10)} AND tenant_id = ${ctx.tenant.id}
       LIMIT 1
     `;
@@ -3736,16 +3854,16 @@ function buildRouter(sql2, usersTable) {
     delete parsed.tenant_id;
     if (Object.keys(parsed).length === 0) {
       const name2 = internalName(ctx);
-      const [row2] = await sql2`
-        SELECT * FROM ${sql2(name2)}
+      const [row2] = await sql4`
+        SELECT * FROM ${sql4(name2)}
         WHERE id = ${parseInt(ctx.params.id, 10)} AND tenant_id = ${ctx.tenant.id}
         LIMIT 1
       `;
       return Response.json(row2 ?? { error: "Not found" }, { status: row2 ? 200 : 404 });
     }
     const name = internalName(ctx);
-    const [row] = await sql2`
-      UPDATE ${sql2(name)} SET ${sql2(parsed)}
+    const [row] = await sql4`
+      UPDATE ${sql4(name)} SET ${sql4(parsed)}
       WHERE id = ${parseInt(ctx.params.id, 10)} AND tenant_id = ${ctx.tenant.id}
       RETURNING *
     `;
@@ -3754,8 +3872,8 @@ function buildRouter(sql2, usersTable) {
   });
   r.delete("/:_slug/:id", async (_req, ctx) => {
     const name = internalName(ctx);
-    const result = await sql2`
-      DELETE FROM ${sql2(name)}
+    const result = await sql4`
+      DELETE FROM ${sql4(name)}
       WHERE id = ${parseInt(ctx.params.id, 10)} AND tenant_id = ${ctx.tenant.id}
       RETURNING 1
     `;
@@ -3766,11 +3884,11 @@ function buildRouter(sql2, usersTable) {
   });
   async function handleNested(req, ctx, method) {
     const [parentTable, nestedSlug] = await Promise.all([
-      getUserTable(sql2, ctx.tenant.id, ctx.params["_slug"]),
+      getUserTable(sql4, ctx.tenant.id, ctx.params["_slug"]),
       ctx.params["_nested"]
     ]);
     if (!parentTable) return Response.json({ error: "Parent table not found" }, { status: 404 });
-    const childTable = await getUserTable(sql2, ctx.tenant.id, nestedSlug);
+    const childTable = await getUserTable(sql4, ctx.tenant.id, nestedSlug);
     if (!childTable) return Response.json({ error: "Nested table not found" }, { status: 404 });
     const relField = findRelation(childTable.fields, ctx.params["_slug"]);
     if (!relField) {
@@ -3780,18 +3898,18 @@ function buildRouter(sql2, usersTable) {
     if (relFields.length === 2) {
       const otherRel = relFields.find((f) => f.name !== relField.name);
       const targetSlug = otherRel.relation.table;
-      const targetTable = await getUserTable(sql2, ctx.tenant.id, targetSlug);
+      const targetTable = await getUserTable(sql4, ctx.tenant.id, targetSlug);
       if (!targetTable) return Response.json({ error: "Target table not found" }, { status: 404 });
       const childName2 = internalTableName(ctx.tenant.id, nestedSlug);
       const targetName = internalTableName(ctx.tenant.id, targetSlug);
       const parentId2 = parseInt(ctx.params.id, 10);
       if (method === "GET") {
         const [rows, countResult] = await Promise.all([
-          sql2.unsafe(
+          sql4.unsafe(
             `SELECT t.* FROM "${targetName}" t JOIN "${childName2}" j ON j."${otherRel.name}" = t.id WHERE j."${relField.name}" = $1 AND t.tenant_id = $2 ORDER BY t.id DESC`,
             [parentId2, ctx.tenant.id]
           ),
-          sql2.unsafe(
+          sql4.unsafe(
             `SELECT count(*) as count FROM "${targetName}" t JOIN "${childName2}" j ON j."${otherRel.name}" = t.id WHERE j."${relField.name}" = $1 AND t.tenant_id = $2`,
             [parentId2, ctx.tenant.id]
           )
@@ -3804,11 +3922,11 @@ function buildRouter(sql2, usersTable) {
     const parentId = parseInt(ctx.params.id, 10);
     if (method === "GET") {
       const [rows, countResult] = await Promise.all([
-        sql2.unsafe(
+        sql4.unsafe(
           `SELECT * FROM "${childName}" WHERE "${relField.name}" = $1 AND tenant_id = $2 ORDER BY id DESC`,
           [parentId, ctx.tenant.id]
         ),
-        sql2.unsafe(
+        sql4.unsafe(
           `SELECT count(*) as count FROM "${childName}" WHERE "${relField.name}" = $1 AND tenant_id = $2`,
           [parentId, ctx.tenant.id]
         )
@@ -3825,7 +3943,7 @@ function buildRouter(sql2, usersTable) {
     parsed.tenant_id = ctx.tenant.id;
     parsed[relField.name] = parentId;
     delete parsed.id;
-    const [row] = await sql2`INSERT INTO ${sql2(childName)} ${sql2(parsed)} RETURNING *`;
+    const [row] = await sql4`INSERT INTO ${sql4(childName)} ${sql4(parsed)} RETURNING *`;
     return Response.json(row, { status: 201 });
   }
   r.get("/:_slug/:id/:_nested", async (req, ctx) => handleNested(req, ctx, "GET"));
@@ -4067,15 +4185,15 @@ function buildMutationFields(tables, ctx) {
   }
   return fields;
 }
-function buildGraphQLHandler(sql2) {
+function buildGraphQLHandler(sql4) {
   const r = new Router();
   r.post("/", async (req, ctx) => {
-    const tables = await sql2`
+    const tables = await sql4`
       SELECT * FROM "_user_tables"
       WHERE tenant_id = ${ctx.tenant.id}
       ORDER BY created_at ASC
     `;
-    const buildCtx = { sql: sql2, tenantId: ctx.tenant.id, tables };
+    const buildCtx = { sql: sql4, tenantId: ctx.tenant.id, tables };
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: "Query",
@@ -4110,12 +4228,12 @@ function buildGraphQLHandler(sql2) {
     });
   });
   async function handleGET(req, _ctx) {
-    const tables = await sql2`
+    const tables = await sql4`
       SELECT * FROM "_user_tables"
       WHERE tenant_id = ${_ctx.tenant.id}
       ORDER BY created_at ASC
     `;
-    const buildCtx = { sql: sql2, tenantId: _ctx.tenant.id, tables };
+    const buildCtx = { sql: sql4, tenantId: _ctx.tenant.id, tables };
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: "Query",
@@ -4145,18 +4263,18 @@ function buildGraphQLHandler(sql2) {
 // tenant/client.ts
 function tenant(options) {
   const pg = options.pg;
-  const sql2 = pg.sql;
+  const sql4 = pg.sql;
   const usersTable = options.usersTable;
   const base = new PgModule(pg);
   return {
-    migrate: () => migrate2({ sql: sql2, usersTable }),
+    migrate: () => migrate2({ sql: sql4, usersTable }),
     middleware() {
       return async (req, ctx, next) => {
         const user2 = ctx.user;
         if (!user2) {
           return new Response("Unauthorized", { status: 401 });
         }
-        const members = await sql2`
+        const members = await sql4`
           SELECT tm.role, t.id, t.name
           FROM "_tenant_members" tm
           JOIN "_tenants" t ON t.id = tm.tenant_id
@@ -4185,8 +4303,8 @@ function tenant(options) {
         return next(req, ctx);
       };
     },
-    router: () => buildRouter(sql2, usersTable),
-    graphql: () => buildGraphQLHandler(sql2),
+    router: () => buildRouter(sql4, usersTable),
+    graphql: () => buildGraphQLHandler(sql4),
     close: () => base.close()
   };
 }
@@ -4196,7 +4314,7 @@ import { createOpenAI } from "@ai-sdk/openai";
 
 // agent/migrate.ts
 async function migrate3(opts) {
-  const { sql: sql2, embeddingDimension } = opts;
+  const { sql: sql4, embeddingDimension } = opts;
   const agents = pgTable("_agents", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id"),
@@ -4210,8 +4328,8 @@ async function migrate3(opts) {
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`),
     updated_at: timestamptz("updated_at").notNull().default(sql`NOW()`)
   });
-  await agents.create(sql2);
-  await agents.createIndex(sql2, "tenant_id");
+  await agents.create(sql4);
+  await agents.createIndex(sql4, "tenant_id");
   const docs = pgTable("_knowledge_documents", {
     id: serial("id").primaryKey(),
     agent_id: integer("agent_id").notNull().references("_agents", "id", "cascade"),
@@ -4221,22 +4339,22 @@ async function migrate3(opts) {
     metadata: jsonb("metadata").notNull().default(sql`'{}'::jsonb`),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await docs.create(sql2);
-  await docs.createIndex(sql2, "agent_id");
+  await docs.create(sql4);
+  await docs.createIndex(sql4, "agent_id");
 }
 
 // agent/rest.ts
-async function getAgent(sql2, id2) {
-  const [row] = await sql2`SELECT * FROM "_agents" WHERE id = ${id2} LIMIT 1`;
-  return row ?? null;
-}
 function buildRouter2(deps) {
-  const { sql: sql2, runner } = deps;
+  const { sql: sql4, agents: agentsTable, runner } = deps;
+  async function getAgent(id2) {
+    const row = await agentsTable.read(id2);
+    return row ?? null;
+  }
   const r = new Router();
   r.post("/agents", async (req) => {
     const body = await req.json();
     if (!body.name) return Response.json({ error: "name is required" }, { status: 400 });
-    const [row] = await sql2`
+    const [row] = await sql4`
       INSERT INTO "_agents" ("name", "description", "type", "model", "system_prompt", "owner_id")
       VALUES (${body.name}, ${body.description || ""}, ${body.type || "chat"}, ${body.model || ""}, ${body.system_prompt || ""}, ${body.owner_id || 1})
       RETURNING *
@@ -4244,17 +4362,17 @@ function buildRouter2(deps) {
     return Response.json(row, { status: 201 });
   });
   r.get("/agents", async () => {
-    const rows = await sql2`SELECT * FROM "_agents" ORDER BY created_at DESC`;
+    const { data: rows } = await agentsTable.readMany(void 0, { orderBy: { created_at: "desc" } });
     return Response.json(rows);
   });
   r.get("/agents/:id", async (_req, ctx) => {
-    const agent2 = await getAgent(sql2, parseInt(ctx.params.id, 10));
+    const agent2 = await getAgent(parseInt(ctx.params.id, 10));
     if (!agent2) return Response.json({ error: "Agent not found" }, { status: 404 });
     return Response.json(agent2);
   });
   r.patch("/agents/:id", async (req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    const agent2 = await getAgent(sql2, id2);
+    const agent2 = await getAgent(id2);
     if (!agent2) return Response.json({ error: "Agent not found" }, { status: 404 });
     const body = await req.json();
     const fields = [];
@@ -4269,7 +4387,7 @@ function buildRouter2(deps) {
     if (fields.length === 0) return Response.json({ error: "No fields to update" }, { status: 400 });
     values.push(id2);
     fields.push(`"updated_at" = NOW()`);
-    const [row] = await sql2.unsafe(
+    const [row] = await sql4.unsafe(
       `UPDATE "_agents" SET ${fields.join(", ")} WHERE id = $${idx} RETURNING *`,
       values
     );
@@ -4277,7 +4395,7 @@ function buildRouter2(deps) {
   });
   r.delete("/agents/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    const [row] = await sql2`DELETE FROM "_agents" WHERE id = ${id2} RETURNING 1`;
+    const [row] = await sql4`DELETE FROM "_agents" WHERE id = ${id2} RETURNING 1`;
     if (!row) return Response.json({ error: "Agent not found" }, { status: 404 });
     return Response.json({ ok: true });
   });
@@ -4301,7 +4419,7 @@ function buildRouter2(deps) {
   });
   r.post("/agents/:id/knowledge", async (req, ctx) => {
     const agentId = parseInt(ctx.params.id, 10);
-    const agent2 = await getAgent(sql2, agentId);
+    const agent2 = await getAgent(agentId);
     if (!agent2) return Response.json({ error: "Agent not found" }, { status: 404 });
     const body = await req.json();
     if (!body.content) return Response.json({ error: "content is required" }, { status: 400 });
@@ -4314,7 +4432,7 @@ function buildRouter2(deps) {
   });
   r.get("/agents/:id/knowledge", async (_req, ctx) => {
     const agentId = parseInt(ctx.params.id, 10);
-    const rows = await sql2`
+    const rows = await sql4`
       SELECT id, title, created_at FROM "_knowledge_documents"
       WHERE agent_id = ${agentId}
       ORDER BY created_at DESC
@@ -4324,7 +4442,7 @@ function buildRouter2(deps) {
   r.delete("/agents/:id/knowledge/:docId", async (_req, ctx) => {
     const agentId = parseInt(ctx.params.id, 10);
     const docId = parseInt(ctx.params.docId, 10);
-    await sql2`DELETE FROM "_knowledge_documents" WHERE id = ${docId} AND agent_id = ${agentId}`;
+    await sql4`DELETE FROM "_knowledge_documents" WHERE id = ${docId} AND agent_id = ${agentId}`;
     return Response.json({ ok: true });
   });
   return r;
@@ -4380,6 +4498,9 @@ function createSSEStream(iterable, opts) {
 }
 
 // agent/run.ts
+function hasKnowledgeDocs(sql4, agentId) {
+  return sql4`SELECT 1 FROM "_knowledge_documents" WHERE agent_id = ${agentId} LIMIT 1`.then((r) => r.length > 0);
+}
 function chunkContent(content, chunkSize = 512, overlap = 64) {
   const paragraphs = content.split(/\n\n+/);
   const chunks = [];
@@ -4394,31 +4515,28 @@ function chunkContent(content, chunkSize = 512, overlap = 64) {
   if (current) chunks.push(current);
   return chunks;
 }
-function hasKnowledgeDocs(sql2, agentId) {
-  return sql2`SELECT 1 FROM "_knowledge_documents" WHERE agent_id = ${agentId} LIMIT 1`.then((r) => r.length > 0);
-}
-async function searchKnowledge(sql2, embedModel, agentId, query, limit = 5) {
+async function searchKnowledge(sql4, embedModel, agentId, query, limit = 5) {
   const { embedding } = await embed({ model: embedModel, value: query });
   const vec = `[${embedding.join(",")}]`;
-  const docs = await sql2.unsafe(
+  const docs = await sql4.unsafe(
     `SELECT id, title, content, metadata, embedding <=> $1::vector AS _score FROM "_knowledge_documents" WHERE agent_id = $2 ORDER BY embedding <=> $1::vector LIMIT $3`,
     [vec, agentId, limit]
   );
   return docs.map((d) => ({ id: d.id, title: d.title, content: d.content, score: d._score }));
 }
-async function loadAgent(sql2, agentId) {
-  const [row] = await sql2`SELECT * FROM "_agents" WHERE id = ${agentId} LIMIT 1`;
+async function loadAgent(agents, agentId) {
+  const row = await agents.read(agentId);
   return row ?? null;
 }
 function createRunner(deps) {
-  const { sql: sql2, getModel, getEmbeddingModel, userTools } = deps;
+  const { sql: sql4, agents, getModel, getEmbeddingModel, userTools } = deps;
   async function run(agentId, params) {
-    const agent2 = await loadAgent(sql2, agentId);
+    const agent2 = await loadAgent(agents, agentId);
     if (!agent2 || !agent2.active) throw new Error("Agent not found or inactive");
     const model = getModel();
     const embedModel = getEmbeddingModel();
     const start = Date.now();
-    const hasKB = await hasKnowledgeDocs(sql2, agentId);
+    const hasKB = await hasKnowledgeDocs(sql4, agentId);
     const messages2 = params.messages ?? [];
     if (messages2.length === 0) {
       messages2.push({ role: "user", content: params.input });
@@ -4432,7 +4550,7 @@ function createRunner(deps) {
           limit: z4.number().default(5).describe("\u8FD4\u56DE\u7ED3\u679C\u6570\u91CF")
         }),
         execute: async ({ query, limit }) => {
-          return searchKnowledge(sql2, embedModel, agentId, query, limit);
+          return searchKnowledge(sql4, embedModel, agentId, query, limit);
         }
       };
     }
@@ -4481,13 +4599,13 @@ function createRunner(deps) {
     const [first] = chunks;
     const { embedding } = await embed({ model: embedModel, value: first });
     const vec = `[${embedding.join(",")}]`;
-    const [doc] = await sql2.unsafe(
+    const [doc] = await sql4.unsafe(
       `INSERT INTO "_knowledge_documents" ("agent_id", "title", "content", "embedding") VALUES ($1, $2, $3, $4::vector) RETURNING *`,
       [agentId, title, first, vec]
     );
     for (let i = 1; i < chunks.length; i++) {
       const { embedding: emb } = await embed({ model: embedModel, value: chunks[i] });
-      await sql2.unsafe(
+      await sql4.unsafe(
         `INSERT INTO "_knowledge_documents" ("agent_id", "title", "content", "embedding") VALUES ($1, $2, $3, $4::vector)`,
         [agentId, `${title} (${i + 1})`, chunks[i], `[${emb.join(",")}]`]
       );
@@ -4512,7 +4630,7 @@ function createModelsFromEnv() {
 }
 function agent(options) {
   const pg = options.pg;
-  const sql2 = pg.sql;
+  const sql4 = pg.sql;
   const model = options.model;
   const embeddingModel = options.embeddingModel;
   const dimension = options.embeddingDimension ?? 1024;
@@ -4527,11 +4645,33 @@ function agent(options) {
     if (!defaultModels) defaultModels = createModelsFromEnv();
     return defaultModels.embeddingModel;
   }
-  const runner = createRunner({ sql: sql2, getModel, getEmbeddingModel, userTools: options.tools });
+  const agentsTable = pg.table("_agents", {
+    id: serial("id"),
+    tenant_id: text("tenant_id"),
+    name: text("name"),
+    description: text("description"),
+    type: text("type"),
+    model: text("model"),
+    system_prompt: text("system_prompt"),
+    owner_id: integer("owner_id"),
+    active: boolean_("active"),
+    created_at: timestamptz("created_at"),
+    updated_at: timestamptz("updated_at")
+  });
+  const knowledgeTable = pg.table("_knowledge_documents", {
+    id: serial("id"),
+    agent_id: integer("agent_id"),
+    title: text("title"),
+    content: text("content"),
+    embedding: vector("embedding", dimension),
+    metadata: jsonb("metadata"),
+    created_at: timestamptz("created_at")
+  });
+  const runner = createRunner({ sql: sql4, agents: agentsTable, knowledge: knowledgeTable, getModel, getEmbeddingModel, userTools: options.tools });
   const base = new PgModule(pg);
   return {
-    migrate: () => migrate3({ sql: sql2, embeddingDimension: dimension }),
-    router: () => buildRouter2({ sql: sql2, runner }),
+    migrate: () => migrate3({ sql: sql4, embeddingDimension: dimension }),
+    router: () => buildRouter2({ sql: sql4, agents: agentsTable, runner }),
     run: (agentId, params) => runner.run(agentId, params),
     addKnowledge: (agentId, title, content) => runner.addKnowledge(agentId, title, content),
     close: () => base.close()
@@ -4539,7 +4679,7 @@ function agent(options) {
 }
 
 // messager/migrate.ts
-async function migrate4(sql2) {
+async function migrate4(sql4) {
   const channels2 = pgTable("_channels", {
     id: serial("id").primaryKey(),
     tenant_id: text("tenant_id"),
@@ -4548,8 +4688,8 @@ async function migrate4(sql2) {
     created_by: integer("created_by").notNull(),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await channels2.create(sql2);
-  await channels2.createIndex(sql2, "tenant_id");
+  await channels2.create(sql4);
+  await channels2.createIndex(sql4, "tenant_id");
   const members = pgTable("_channel_members", {
     id: serial("id").primaryKey(),
     channel_id: integer("channel_id").notNull().references("_channels", "id", "cascade"),
@@ -4559,9 +4699,9 @@ async function migrate4(sql2) {
     last_read_id: integer("last_read_id"),
     last_read_at: timestamptz("last_read_at")
   });
-  await members.create(sql2);
-  await members.createIndex(sql2, "member_id");
-  await sql2.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_channel_members_unique_idx" ON "_channel_members" ("channel_id", "member_id", "member_type")`);
+  await members.create(sql4);
+  await members.createIndex(sql4, "member_id");
+  await sql4.unsafe(`CREATE UNIQUE INDEX IF NOT EXISTS "_channel_members_unique_idx" ON "_channel_members" ("channel_id", "member_id", "member_type")`);
   const messages2 = pgTable("_messages", {
     id: serial("id").primaryKey(),
     channel_id: integer("channel_id").notNull().references("_channels", "id", "cascade"),
@@ -4575,8 +4715,8 @@ async function migrate4(sql2) {
     mime_type: text("mime_type"),
     created_at: timestamptz("created_at").notNull().default(sql`NOW()`)
   });
-  await messages2.create(sql2);
-  await messages2.createIndex(sql2, ["channel_id", "created_at"], { desc: true });
+  await messages2.create(sql4);
+  await messages2.createIndex(sql4, ["channel_id", "created_at"], { desc: true });
 }
 
 // messager/ws.ts
@@ -4613,7 +4753,7 @@ function unsubscribe(ws) {
   }
 }
 function createWSHandler(deps) {
-  const { sql: sql2, agents } = deps;
+  const { sql: sql4, agents } = deps;
   return {
     open(ws, ctx) {
       const userId = ctx.user?.id;
@@ -4636,7 +4776,7 @@ function createWSHandler(deps) {
       switch (type) {
         case "message": {
           if (!content || !channel_id) return;
-          const [row] = await sql2`
+          const [row] = await sql4`
             INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
             VALUES (${channel_id}, ${userId}, 'user', ${content})
             RETURNING *
@@ -4645,14 +4785,14 @@ function createWSHandler(deps) {
           broadcastToChannel(channel_id, { type: "message", data: message });
           subscribe(ws, userId, channel_id);
           if (agents) {
-            const agentMembers = await sql2`
+            const agentMembers = await sql4`
               SELECT member_id FROM "_channel_members"
               WHERE channel_id = ${channel_id} AND member_type = 'agent'
             `;
             for (const am of agentMembers) {
               agents.run(am.member_id, { input: content, stream: false }).then((result) => {
                 if ("output" in result && result.output) {
-                  sql2`
+                  sql4`
                     INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
                     VALUES (${channel_id}, ${am.member_id}, 'agent', ${result.output})
                   `.then(([r]) => {
@@ -4681,7 +4821,7 @@ function createWSHandler(deps) {
         case "read": {
           if (!channel_id || !last_message_id) return;
           subscribe(ws, userId, channel_id);
-          await sql2`
+          await sql4`
             UPDATE "_channel_members"
             SET last_read_id = ${last_message_id}, last_read_at = NOW()
             WHERE channel_id = ${channel_id} AND member_id = ${userId} AND member_type = 'user'
@@ -4707,24 +4847,24 @@ function createWSHandler(deps) {
 
 // messager/rest.ts
 function buildRouter3(deps) {
-  const { sql: sql2, agents } = deps;
+  const { sql: sql4, channels: channels2, members, messages: messages2, agents } = deps;
   const r = new Router();
   r.post("/channels", async (req) => {
     const body = await req.json();
     if (!body.name) return Response.json({ error: "name is required" }, { status: 400 });
-    const [ch] = await sql2`
+    const [ch] = await sql4`
       INSERT INTO "_channels" ("name", "type", "created_by")
       VALUES (${body.name}, ${body.type || "channel"}, ${body.created_by || 1})
       RETURNING *
     `;
     const channel = ch;
-    await sql2`
+    await sql4`
       INSERT INTO "_channel_members" ("channel_id", "member_id", "member_type", "role")
       VALUES (${channel.id}, ${channel.created_by}, 'user', 'admin')
     `;
     if (Array.isArray(body.members)) {
       for (const m of body.members) {
-        await sql2`
+        await sql4`
           INSERT INTO "_channel_members" ("channel_id", "member_id", "member_type", "role")
           VALUES (${channel.id}, ${m.member_id ?? m}, ${m.member_type ?? "user"}, ${m.role ?? "member"})
           ON CONFLICT DO NOTHING
@@ -4735,7 +4875,7 @@ function buildRouter3(deps) {
   });
   r.get("/channels", async (_req, ctx) => {
     const userId = ctx.user?.id ?? 1;
-    const rows = await sql2`
+    const rows = await sql4`
       SELECT c.*, (
         SELECT content FROM "_messages"
         WHERE channel_id = c.id
@@ -4750,22 +4890,20 @@ function buildRouter3(deps) {
   });
   r.get("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    const [ch] = await sql2`SELECT * FROM "_channels" WHERE id = ${id2} LIMIT 1`;
+    const ch = await channels2.read(id2);
     if (!ch) return Response.json({ error: "Channel not found" }, { status: 404 });
-    const members = await sql2`
-      SELECT * FROM "_channel_members" WHERE channel_id = ${id2}
-    `;
-    return Response.json({ channel: ch, members });
+    const { data: memberRows } = await members.readMany({ channel_id: id2 });
+    return Response.json({ channel: ch, members: memberRows });
   });
   r.delete("/channels/:id", async (_req, ctx) => {
     const id2 = parseInt(ctx.params.id, 10);
-    await sql2`DELETE FROM "_channels" WHERE id = ${id2}`;
+    await sql4`DELETE FROM "_channels" WHERE id = ${id2}`;
     return Response.json({ ok: true });
   });
   r.post("/channels/:id/members", async (req, ctx) => {
     const channelId = parseInt(ctx.params.id, 10);
     const body = await req.json();
-    await sql2`
+    await sql4`
       INSERT INTO "_channel_members" ("channel_id", "member_id", "member_type", "role")
       VALUES (${channelId}, ${body.member_id}, ${body.member_type || "user"}, ${body.role || "member"})
       ON CONFLICT DO NOTHING
@@ -4775,7 +4913,7 @@ function buildRouter3(deps) {
   r.delete("/channels/:id/members/:memberId", async (_req, ctx) => {
     const channelId = parseInt(ctx.params.id, 10);
     const memberId = parseInt(ctx.params.memberId, 10);
-    await sql2`
+    await sql4`
       DELETE FROM "_channel_members"
       WHERE channel_id = ${channelId} AND member_id = ${memberId}
     `;
@@ -4787,25 +4925,23 @@ function buildRouter3(deps) {
     const limit = Math.min(parseInt(url.searchParams.get("limit") || "50", 10), 100);
     const before = url.searchParams.get("before");
     if (before) {
-      const rows2 = await sql2`
-        SELECT * FROM "_messages"
-        WHERE channel_id = ${channelId} AND id < ${parseInt(before, 10)}
-        ORDER BY created_at DESC LIMIT ${limit}
-      `;
+      const { data: rows2 } = await messages2.readMany(
+        [eq("channel_id", channelId), lt("id", parseInt(before, 10))],
+        { orderBy: { created_at: "desc" }, limit }
+      );
       return Response.json({ rows: rows2.reverse(), count: rows2.length });
     }
-    const rows = await sql2`
-      SELECT * FROM "_messages"
-      WHERE channel_id = ${channelId}
-      ORDER BY created_at DESC LIMIT ${limit}
-    `;
+    const { data: rows } = await messages2.readMany(
+      { channel_id: channelId },
+      { orderBy: { created_at: "desc" }, limit }
+    );
     return Response.json({ rows: rows.reverse(), count: rows.length });
   });
   r.post("/channels/:id/messages", async (req, ctx) => {
     const channelId = parseInt(ctx.params.id, 10);
     const body = await req.json();
     if (!body.content) return Response.json({ error: "content is required" }, { status: 400 });
-    const [row] = await sql2`
+    const [row] = await sql4`
       INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "type", "content")
       VALUES (${channelId}, ${body.sender_id ?? 1}, ${body.sender_type || "user"}, ${body.type || "text"}, ${body.content})
       RETURNING *
@@ -4813,14 +4949,14 @@ function buildRouter3(deps) {
     const msg = row;
     broadcastToChannel(channelId, { type: "message", data: msg });
     if (agents) {
-      const agentMembers = await sql2`
+      const agentMembers = await sql4`
         SELECT member_id FROM "_channel_members"
         WHERE channel_id = ${channelId} AND member_type = 'agent'
       `;
       for (const am of agentMembers) {
         agents.run(am.member_id, { input: body.content, stream: false }).then((result) => {
           if ("output" in result && result.output) {
-            sql2`
+            sql4`
               INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "content")
               VALUES (${channelId}, ${am.member_id}, 'agent', ${result.output})
             `.then(([r2]) => {
@@ -4840,7 +4976,7 @@ function buildRouter3(deps) {
     const channelId = parseInt(ctx.params.id, 10);
     const body = await req.json();
     const userId = body.user_id ?? ctx.user?.id ?? 1;
-    await sql2`
+    await sql4`
       UPDATE "_channel_members"
       SET last_read_id = ${body.last_message_id}, last_read_at = NOW()
       WHERE channel_id = ${channelId} AND member_id = ${userId} AND member_type = 'user'
@@ -4857,15 +4993,45 @@ function buildRouter3(deps) {
 // messager/client.ts
 function messager(options) {
   const pg = options.pg;
-  const sql2 = pg.sql;
+  const sql4 = pg.sql;
   const agents = options.agents;
   const base = new PgModule(pg);
+  const channels2 = pg.table("_channels", {
+    id: serial("id"),
+    tenant_id: text("tenant_id"),
+    name: text("name"),
+    type: text("type"),
+    created_by: integer("created_by"),
+    created_at: timestamptz("created_at")
+  });
+  const members = pg.table("_channel_members", {
+    id: serial("id"),
+    channel_id: integer("channel_id"),
+    member_id: integer("member_id"),
+    member_type: text("member_type"),
+    role: text("role"),
+    last_read_id: integer("last_read_id"),
+    last_read_at: timestamptz("last_read_at")
+  });
+  const messages2 = pg.table("_messages", {
+    id: serial("id"),
+    channel_id: integer("channel_id"),
+    sender_id: integer("sender_id"),
+    sender_type: text("sender_type"),
+    type: text("type"),
+    content: text("content"),
+    file_url: text("file_url"),
+    file_name: text("file_name"),
+    file_size: integer("file_size"),
+    mime_type: text("mime_type"),
+    created_at: timestamptz("created_at")
+  });
   return {
-    migrate: () => migrate4(sql2),
-    router: () => buildRouter3({ sql: sql2, agents }),
-    wsHandler: () => createWSHandler({ sql: sql2, agents }),
+    migrate: () => migrate4(sql4),
+    router: () => buildRouter3({ sql: sql4, channels: channels2, members, messages: messages2, agents }),
+    wsHandler: () => createWSHandler({ sql: sql4, agents }),
     async send(channelId, content, opts) {
-      const [row] = await sql2`
+      const [row] = await sql4`
         INSERT INTO "_messages" ("channel_id", "sender_id", "sender_type", "type", "content")
         VALUES (${channelId}, ${opts?.sender_id ?? 0}, ${opts?.sender_type ?? "system"}, ${opts?.type ?? "text"}, ${content})
         RETURNING *
@@ -5432,7 +5598,7 @@ function ensureCertificates(config) {
 import { createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 
 // opencode/migrate.ts
-async function migrate5(sql2) {
+async function migrate5(sql4) {
   const sessions2 = pgTable("_opencode_sessions", {
     id: uuid("id").default(sql`gen_random_uuid()`).primaryKey(),
     tenant_id: text("tenant_id"),
@@ -5447,8 +5613,8 @@ async function migrate5(sql2) {
     created_at: timestamptz("created_at").default(sql`NOW()`),
     updated_at: timestamptz("updated_at").default(sql`NOW()`)
   });
-  await sessions2.create(sql2);
-  await sessions2.createIndex(sql2, "user_id");
+  await sessions2.create(sql4);
+  await sessions2.createIndex(sql4, "user_id");
   const messages2 = pgTable("_opencode_messages", {
     id: serial("id").primaryKey(),
     session_id: uuid("session_id").notNull().references("_opencode_sessions", "id", "cascade"),
@@ -5460,8 +5626,8 @@ async function migrate5(sql2) {
     tokens_out: integer("tokens_out").default(0),
     created_at: timestamptz("created_at").default(sql`NOW()`)
   });
-  await messages2.create(sql2);
-  await messages2.createIndex(sql2, ["session_id", "created_at"]);
+  await messages2.create(sql4);
+  await messages2.createIndex(sql4, ["session_id", "created_at"]);
 }
 
 // opencode/session.ts
@@ -5490,11 +5656,11 @@ var messages = pgTable("_opencode_messages", {
   tokens_out: integer("tokens_out"),
   created_at: timestamptz("created_at")
 });
-async function createSession(sql2, opts, cwd, mountPath) {
+async function createSession(sql4, opts, cwd, mountPath) {
   const id2 = randomUUID2();
   const ws = computeSessionWorkspace(cwd, mountPath, id2);
   await mkdir2(ws, { recursive: true });
-  const [row] = await sql2`
+  const [row] = await sql4`
     INSERT INTO "_opencode_sessions" ("id", "user_id", "title", "model", "workspace", "system_prompt")
     VALUES (${id2}, ${opts.userId ?? 0}, ${opts.title ?? null}, ${opts.model ?? "deepseek-v4-flash"}, ${ws}, ${opts.systemPrompt ?? null})
     RETURNING *
@@ -5505,39 +5671,39 @@ function computeSessionWorkspace(cwd, mountPath, sessionId) {
   const name = !mountPath || mountPath === "/" ? "default" : mountPath.replace(/^\//, "");
   return join3(cwd, ".sessions", name, sessionId);
 }
-async function getSession(sql2, id2) {
-  const rows = await sessions.find(sql2, { id: id2, active: true });
+async function getSession(sql4, id2) {
+  const { data: rows } = await sessions.readMany(sql4, { id: id2, active: true });
   return rows[0] ?? null;
 }
-async function listSessions(sql2, userId) {
+async function listSessions(sql4, userId) {
   const opts = { orderBy: { updated_at: "desc" } };
   if (userId !== void 0) {
-    const rows2 = await sessions.find(sql2, { user_id: userId, active: true }, opts);
+    const { data: rows2 } = await sessions.readMany(sql4, { user_id: userId, active: true }, opts);
     return rows2;
   }
-  const rows = await sessions.find(sql2, { active: true }, opts);
+  const { data: rows } = await sessions.readMany(sql4, { active: true }, opts);
   return rows;
 }
-async function deleteSession(sql2, id2) {
-  await sessions.update(sql2, { id: id2 }, { active: false, updated_at: sql`NOW()` });
+async function deleteSession(sql4, id2) {
+  await sessions.update(sql4, id2, { active: false, updated_at: sql`NOW()` });
 }
-async function getHistory(sql2, sessionId, limit = 50) {
-  const rows = await messages.find(sql2, { session_id: sessionId }, {
+async function getHistory(sql4, sessionId, limit = 50) {
+  const { data: rows } = await messages.readMany(sql4, { session_id: sessionId }, {
     orderBy: { created_at: "asc" },
     limit
   });
   return rows;
 }
-async function addTextMessage(sql2, sessionId, role, content, tokensIn = 0, tokensOut = 0) {
-  const [row] = await sql2`
+async function addTextMessage(sql4, sessionId, role, content, tokensIn = 0, tokensOut = 0) {
+  const [row] = await sql4`
     INSERT INTO "_opencode_messages" ("session_id", "role", "content", "tokens_in", "tokens_out")
     VALUES (${sessionId}, ${role}, ${content}, ${tokensIn}, ${tokensOut})
     RETURNING *
   `;
   return row;
 }
-async function addToolMessages(sql2, sessionId, toolCalls, toolResults) {
-  const [row] = await sql2`
+async function addToolMessages(sql4, sessionId, toolCalls, toolResults) {
+  const [row] = await sql4`
     INSERT INTO "_opencode_messages" ("session_id", "role", "tool_calls", "tool_results")
     VALUES (${sessionId}, 'tool', ${JSON.stringify(toolCalls)}, ${JSON.stringify(toolResults)})
     RETURNING *
@@ -5548,7 +5714,7 @@ async function addToolMessages(sql2, sessionId, toolCalls, toolResults) {
 // opencode/run.ts
 import { streamText as streamText2, stepCountIs } from "ai";
 async function* executeGenerator(opts) {
-  const { sessionId, input, model, tools, systemPrompt, messages: messages2, sql: sql2, abortSignal } = opts;
+  const { sessionId, input, model, tools, systemPrompt, messages: messages2, sql: sql4, abortSignal } = opts;
   const lastStepToolCalls = [];
   let currentAssistantText = "";
   let currentUsage = { promptTokens: 0, completionTokens: 0, totalTokens: 0 };
@@ -5577,7 +5743,7 @@ async function* executeGenerator(opts) {
       }
       if (step.toolResults.length > 0) {
         try {
-          await addToolMessages(sql2, sessionId, lastStepToolCalls, step.toolResults);
+          await addToolMessages(sql4, sessionId, lastStepToolCalls, step.toolResults);
         } catch (e) {
           console.error("[opencode] save tool messages failed:", e);
         }
@@ -5591,7 +5757,7 @@ async function* executeGenerator(opts) {
         totalTokens: result2.usage?.totalTokens ?? 0
       };
       try {
-        await addTextMessage(sql2, sessionId, "assistant", currentAssistantText, currentUsage.promptTokens, currentUsage.completionTokens);
+        await addTextMessage(sql4, sessionId, "assistant", currentAssistantText, currentUsage.promptTokens, currentUsage.completionTokens);
       } catch (e) {
         console.error("[opencode] save message failed:", e);
       }
@@ -6024,11 +6190,11 @@ function createTools(ctx) {
 
 // opencode/rest.ts
 async function buildRouter4(deps) {
-  const { sql: sql2, model, workspace, systemPrompt, skills, skillsRegistry, permissions, pendingQuestions } = deps;
+  const { sql: sql4, model, workspace, systemPrompt, skills, skillsRegistry, permissions, pendingQuestions } = deps;
   const router = new Router();
   router.post("/sessions", async (req, ctx) => {
     const body = await req.json().catch(() => ({}));
-    const session = await createSession(sql2, {
+    const session = await createSession(sql4, {
       title: body.title,
       model: body.model,
       systemPrompt: body.systemPrompt || systemPrompt
@@ -6036,24 +6202,24 @@ async function buildRouter4(deps) {
     return Response.json(session, { status: 201 });
   });
   router.get("/sessions", async () => {
-    const sessions2 = await listSessions(sql2);
+    const sessions2 = await listSessions(sql4);
     return Response.json(sessions2);
   });
   router.get("/sessions/:id", async (_req, ctx) => {
     const id2 = ctx.params.id;
-    const session = await getSession(sql2, id2);
+    const session = await getSession(sql4, id2);
     if (!session) return new Response("Not Found", { status: 404 });
-    const messages2 = await getHistory(sql2, id2);
+    const messages2 = await getHistory(sql4, id2);
     return Response.json({ session, messages: messages2 });
   });
   router.delete("/sessions/:id", async (_req, ctx) => {
     const id2 = ctx.params.id;
-    await deleteSession(sql2, id2);
+    await deleteSession(sql4, id2);
     return new Response(null, { status: 204 });
   });
   router.post("/sessions/:id/message", async (req, ctx) => {
     const sessionId = ctx.params.id;
-    const session = await getSession(sql2, sessionId);
+    const session = await getSession(sql4, sessionId);
     if (!session) return new Response("Session Not Found", { status: 404 });
     const { content } = await req.json();
     if (!content) return new Response("Missing content", { status: 400 });
@@ -6071,8 +6237,8 @@ async function buildRouter4(deps) {
       skills: allSkills,
       systemPrompt: session.system_prompt || systemPrompt
     });
-    const history = await getHistory(sql2, sessionId);
-    await addTextMessage(sql2, sessionId, "user", content);
+    const history = await getHistory(sql4, sessionId);
+    await addTextMessage(sql4, sessionId, "user", content);
     const stream = executeGenerator({
       sessionId,
       input: content,
@@ -6080,7 +6246,7 @@ async function buildRouter4(deps) {
       tools,
       systemPrompt: sysPrompt,
       messages: history,
-      sql: sql2
+      sql: sql4
     });
     return createSSEStream(stream);
   });
@@ -6097,7 +6263,7 @@ async function buildRouter4(deps) {
 // opencode/ws.ts
 var clients = /* @__PURE__ */ new WeakMap();
 function createWSHandler2(deps) {
-  const { sql: sql2, model, workspace, systemPrompt, skills, skillsRegistry, permissions, pendingQuestions } = deps;
+  const { sql: sql4, model, workspace, systemPrompt, skills, skillsRegistry, permissions, pendingQuestions } = deps;
   return {
     open(ws, ctx) {
       const userId = ctx.user?.id ?? 0;
@@ -6117,7 +6283,7 @@ function createWSHandler2(deps) {
       switch (msg.type) {
         case "create": {
           try {
-            const session = await createSession(sql2, {
+            const session = await createSession(sql4, {
               userId: client.userId,
               title: msg.title,
               model: msg.model,
@@ -6140,7 +6306,7 @@ function createWSHandler2(deps) {
           client.abortController = controller;
           client.currentSessionId = session_id;
           try {
-            const session = await getSession(sql2, session_id);
+            const session = await getSession(sql4, session_id);
             if (!session) {
               ws.send(JSON.stringify({ type: "error", error: "Session not found" }));
               return;
@@ -6159,8 +6325,8 @@ function createWSHandler2(deps) {
               skills: allSkills,
               systemPrompt: session.system_prompt || systemPrompt
             });
-            const history = await getHistory(sql2, session_id);
-            await addTextMessage(sql2, session_id, "user", content);
+            const history = await getHistory(sql4, session_id);
+            await addTextMessage(sql4, session_id, "user", content);
             const stream = executeGenerator({
               sessionId: session_id,
               input: content,
@@ -6168,7 +6334,7 @@ function createWSHandler2(deps) {
               tools,
               systemPrompt: sysPrompt,
               messages: history,
-              sql: sql2,
+              sql: sql4,
               abortSignal: controller.signal
             });
             for await (const event of stream) {
@@ -6303,7 +6469,7 @@ function buildSkillRegistry(discovered, manual) {
 // opencode/client.ts
 async function opencode(options) {
   const pg = options.pg;
-  const sql2 = pg.sql;
+  const sql4 = pg.sql;
   const baseURL = options.baseURL || process.env.DEEPSEEK_BASE_URL || "https://api.deepseek.com/v1";
   const apiKey = options.apiKey || process.env.DEEPSEEK_API_KEY;
   const workspace = options.workspace || process.cwd();
@@ -6318,9 +6484,9 @@ async function opencode(options) {
   const pendingQuestions = /* @__PURE__ */ new Map();
   const base = new PgModule(pg);
   return {
-    migrate: () => migrate5(sql2),
-    router: () => buildRouter4({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
-    wsHandler: () => createWSHandler2({ sql: sql2, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
+    migrate: () => migrate5(sql4),
+    router: () => buildRouter4({ sql: sql4, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
+    wsHandler: () => createWSHandler2({ sql: sql4, model, workspace, systemPrompt, skills: manualSkills, skillsRegistry, permissions, pendingQuestions }),
     close: () => base.close()
   };
 }
@@ -6424,6 +6590,183 @@ function mailer(options) {
   }
   return { send, close };
 }
+
+// logdb/migrate.ts
+function pad(n) {
+  return n < 10 ? "0" + n : String(n);
+}
+function startOfMonth(year, month) {
+  return new Date(year, month, 1);
+}
+function formatYM(d) {
+  return `${d.getFullYear()}_${pad(d.getMonth() + 1)}`;
+}
+function toISO(d) {
+  return d.toISOString().slice(0, 19) + "+00:00";
+}
+async function ensurePartitions(sql4, tableName) {
+  const now = /* @__PURE__ */ new Date();
+  for (let i = 0; i < 13; i++) {
+    const start = startOfMonth(now.getFullYear(), now.getMonth() + i);
+    const end = startOfMonth(now.getFullYear(), now.getMonth() + i + 1);
+    const partName = `${tableName}_${formatYM(start)}`;
+    await sql4.unsafe(`
+      CREATE TABLE IF NOT EXISTS "${partName}"
+      PARTITION OF "${tableName}"
+      FOR VALUES FROM ('${toISO(start)}') TO ('${toISO(end)}')
+    `);
+  }
+}
+async function migrate6(pg, tableName) {
+  const entries = pgTable(tableName, {
+    id: serial("id"),
+    level: text("level").notNull(),
+    source: text("source").notNull(),
+    message: text("message").notNull(),
+    metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+    created_at: timestamptz("created_at").default(sql`NOW()`)
+  });
+  await entries.create(pg.sql, { partitionBy: partitionBy("range", "created_at") });
+  await entries.createIndex(pg.sql, ["created_at", "id"]);
+  await entries.createIndex(pg.sql, ["level"]);
+  await entries.createIndex(pg.sql, ["source"]);
+  await entries.createIndex(pg.sql, ["level", "created_at"]);
+  await ensurePartitions(pg.sql, tableName);
+}
+
+// logdb/rest.ts
+function createHandler(entries) {
+  return async (req, ctx) => {
+    const body = await req.json();
+    if (!body.level || !body.source || !body.message) {
+      return Response.json({ error: "level, source, message are required" }, { status: 400 });
+    }
+    const metadata = body.metadata ?? {};
+    if (ctx.user) {
+      metadata.user_id = ctx.user.id;
+    }
+    const row = await entries.insert({
+      level: body.level,
+      source: body.source,
+      message: body.message,
+      metadata
+    });
+    if (typeof row.metadata === "string") {
+      try {
+        row.metadata = JSON.parse(row.metadata);
+      } catch {
+      }
+    }
+    return Response.json(row, { status: 201 });
+  };
+}
+function listHandler(entries) {
+  return async (req) => {
+    const url = new URL(req.url);
+    const conditions = [];
+    const level = url.searchParams.get("level");
+    if (level) conditions.push(eq("level", level));
+    const source = url.searchParams.get("source");
+    if (source) conditions.push(eq("source", source));
+    for (const [key, value] of url.searchParams) {
+      if (key.startsWith("meta.")) {
+        conditions.push(contains("metadata", { [key.slice(5)]: value }));
+      }
+    }
+    const after = url.searchParams.get("after");
+    if (after) conditions.push(gte("created_at", after));
+    const before = url.searchParams.get("before");
+    if (before) conditions.push(lt("created_at", before));
+    const limit = parseInt(url.searchParams.get("limit") ?? "50", 10);
+    const offset = parseInt(url.searchParams.get("offset") ?? "0", 10);
+    const { count, data } = await entries.readMany(
+      conditions.length > 0 ? conditions : void 0,
+      { orderBy: { created_at: "desc" }, limit, offset }
+    );
+    for (const row of data) {
+      if (typeof row.metadata === "string") {
+        try {
+          row.metadata = JSON.parse(row.metadata);
+        } catch {
+        }
+      }
+    }
+    return Response.json({ entries: data, total: count });
+  };
+}
+function getHandler(entries) {
+  return async (_req, ctx) => {
+    const id2 = ctx.params?.id;
+    if (!id2) return Response.json({ error: "id is required" }, { status: 400 });
+    const row = await entries.read(parseInt(id2));
+    if (!row) return Response.json({ error: "not found" }, { status: 404 });
+    if (typeof row.metadata === "string") {
+      try {
+        row.metadata = JSON.parse(row.metadata);
+      } catch {
+      }
+    }
+    return Response.json(row);
+  };
+}
+
+// logdb/client.ts
+function logdb(options) {
+  const pg = options.pg;
+  const sql4 = pg.sql;
+  const tableName = options.table ?? "_log_entries";
+  const entries = pg.table(tableName, {
+    id: serial("id"),
+    level: text("level").notNull(),
+    source: text("source").notNull(),
+    message: text("message").notNull(),
+    metadata: jsonb("metadata").default(sql`'{}'::jsonb`),
+    created_at: timestamptz("created_at").default(sql`NOW()`)
+  });
+  async function log(input) {
+    const row = await entries.insert({
+      level: input.level,
+      source: input.source,
+      message: input.message,
+      metadata: input.metadata ?? {}
+    });
+    return row;
+  }
+  function router() {
+    const r = new Router();
+    r.post("/", createHandler(entries));
+    r.get("/", listHandler(entries));
+    r.get("/:id", getHandler(entries));
+    return r;
+  }
+  async function clean(retentionMonths) {
+    const cutoff = /* @__PURE__ */ new Date();
+    cutoff.setMonth(cutoff.getMonth() - retentionMonths);
+    const partitions = await sql4.unsafe(`
+      SELECT relid::regclass::text AS name
+      FROM pg_partition_tree('"${tableName}"'::regclass)
+      WHERE relid IS DISTINCT FROM '"${tableName}"'::regclass
+    `);
+    let dropped = 0;
+    for (const { name } of partitions) {
+      const match = name.match(/_(\d{4})_(\d{2})$/);
+      if (!match) continue;
+      const partDate = new Date(parseInt(match[1]), parseInt(match[2]) - 1);
+      if (partDate < cutoff) {
+        await sql4.unsafe(`DROP TABLE IF EXISTS "${name}"`);
+        dropped++;
+      }
+    }
+    return dropped;
+  }
+  return {
+    log,
+    router,
+    migrate: () => migrate6(pg, tableName),
+    clean,
+    close: () => pg.close()
+  };
+}
 export {
   Router,
   TsxContext,
@@ -6441,6 +6784,7 @@ export {
   health,
   i18n,
   loadEnv,
+  logdb,
   logger,
   mailer,
   messager,