weifuwu 0.27.4 → 0.27.6

package/dist/index.js

@@ -293,14 +293,14 @@ function serve(handler, options) {
     if (!server.listening) return;
     server.close();
     server.closeIdleConnections();
-    return new Promise((resolve4) => {
+    return new Promise((resolve8) => {
       const timer = setTimeout(() => {
         server.closeAllConnections();
-        resolve4();
+        resolve8();
       }, timeoutMs);
       server.on("close", () => {
         clearTimeout(timer);
-        resolve4();
+        resolve8();
       });
     });
   }
@@ -345,7 +345,7 @@ function createHub(opts) {
       }
     });
   }
-  function join3(key, ws) {
+  function join4(key, ws) {
     if (!channels.has(key)) {
       channels.set(key, /* @__PURE__ */ new Set());
       redisSub?.subscribe(`${prefix}${key}`);
@@ -407,7 +407,7 @@ function createHub(opts) {
     redisPub = void 0;
     redisSub = null;
   }
-  return { join: join3, leave, broadcast, close };
+  return { join: join4, leave, broadcast, close };
 }
 
 // core/router.ts
@@ -1176,27 +1176,27 @@ var MIME_TYPES = {
 };
 
 // middleware/validate.ts
-function parseFormBody(text2) {
-  const params = new URLSearchParams(text2);
+function parseFormBody(text) {
+  const params = new URLSearchParams(text);
   const result = {};
   for (const [key, value] of params) {
     result[key] = value;
   }
   return result;
 }
-function parseBody(text2, ct) {
+function parseBody(text, ct) {
   if (ct.includes("application/x-www-form-urlencoded")) {
-    return parseFormBody(text2);
+    return parseFormBody(text);
   }
   const isExplicitJson = ct.includes("application/json") || ct.includes("+json") || ct.includes("text/") || ct.includes("*/json");
   const isNotSpecialMultipart = !ct.includes("multipart/form-data") && !ct.includes("application/x-www-form-urlencoded");
   if (isExplicitJson || isNotSpecialMultipart) {
     try {
-      return JSON.parse(text2);
+      return JSON.parse(text);
     } catch {
     }
   }
-  return text2;
+  return text;
 }
 function validate(schemas) {
   const mw = async (req, ctx, next) => {
@@ -1693,8 +1693,8 @@ function createSSEStream(iterable, opts) {
       async start(controller) {
         try {
           for await (const event of iterable) {
-            const text2 = event.type ? formatSSE(event.type, event) : formatSSEData(event);
-            controller.enqueue(encoder.encode(text2));
+            const text = event.type ? formatSSE(event.type, event) : formatSSEData(event);
+            controller.enqueue(encoder.encode(text));
           }
         } catch (e) {
           if (e instanceof Error && e.name !== "AbortError") {
@@ -1960,7 +1960,7 @@ var TestWSRequest = class {
     const baseUrl = await this.app._ensureServer();
     const wsUrl = baseUrl.replace(/^http/, "ws") + this.path;
     const ws = new WSWebSocket(wsUrl, { handshakeTimeout: this._timeout });
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve8, reject) => {
       const timer = setTimeout(() => {
         reject(new Error(`WebSocket connection timed out after ${this._timeout}ms`));
         ws.close();
@@ -1969,7 +1969,7 @@ var TestWSRequest = class {
         clearTimeout(timer);
         const conn = new TestWSConnection(ws, this._timeout);
         this.app._trackConnection(conn);
-        resolve4(conn);
+        resolve8(conn);
       });
       ws.on("error", (err) => {
         clearTimeout(timer);
@@ -2000,8 +2000,8 @@ var TestWSConnection = class {
     ws.on("message", (data) => {
       const str = data.toString();
       if (this.resolveQueue.length > 0) {
-        const resolve4 = this.resolveQueue.shift();
-        resolve4(str);
+        const resolve8 = this.resolveQueue.shift();
+        resolve8(str);
       } else {
         this.messageQueue.push(str);
       }
@@ -2031,15 +2031,15 @@ var TestWSConnection = class {
     if (this._closed) {
       throw new Error("WebSocket connection closed");
     }
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve8, reject) => {
       const timer = setTimeout(() => {
-        const idx = this.resolveQueue.indexOf(resolve4);
+        const idx = this.resolveQueue.indexOf(resolve8);
         if (idx !== -1) this.resolveQueue.splice(idx, 1);
         reject(new Error(`WebSocket receive timed out after ${timeout ?? this._timeout}ms`));
       }, timeout ?? this._timeout);
       this.resolveQueue.push((msg) => {
         clearTimeout(timer);
-        resolve4(msg);
+        resolve8(msg);
       });
     });
   }
@@ -2053,12 +2053,12 @@ var TestWSConnection = class {
    * Useful for verifying that something did NOT happen.
    */
   async expectSilent(ms) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve8, reject) => {
       if (this.messageQueue.length > 0) {
         reject(new Error(`Expected silence but got message: ${this.messageQueue[0].slice(0, 100)}`));
         return;
       }
-      const timer = setTimeout(() => resolve4(), ms);
+      const timer = setTimeout(() => resolve8(), ms);
       const origPush = this.resolveQueue.push.bind(this.resolveQueue);
       this.resolveQueue.push = (_fn) => {
         clearTimeout(timer);
@@ -2092,17 +2092,17 @@ async function createTestDb(options) {
   await adminSql.unsafe('CREATE SCHEMA IF NOT EXISTS "' + schema.replace(/"/g, '""') + '"');
   const schemaUrl = new URL(dbUrl);
   schemaUrl.searchParams.set("search_path", schema);
-  const sql2 = postgres2(schemaUrl.toString());
+  const sql = postgres2(schemaUrl.toString());
   await adminSql.end();
   return {
-    sql: sql2,
+    sql,
     url: schemaUrl.toString(),
     schema,
     destroy: async () => {
       const destroySql = postgres2(dbUrl);
       await destroySql.unsafe('DROP SCHEMA IF EXISTS "' + schema.replace(/"/g, '""') + '" CASCADE');
       await destroySql.end();
-      await sql2.end();
+      await sql.end();
     }
   };
 }
@@ -2121,15 +2121,15 @@ async function withTestDb(optionsOrFn, fn) {
   const resolvedUrl = dbUrl || process.env.TEST_DATABASE_URL || process.env.DATABASE_URL;
   if (!resolvedUrl) throw new Error("withTestDb: DATABASE_URL or TEST_DATABASE_URL required");
   const { default: postgres2 } = await import("postgres");
-  const sql2 = postgres2(resolvedUrl);
+  const sql = postgres2(resolvedUrl);
   try {
-    await sql2.begin(async (txSql) => {
+    await sql.begin(async (txSql) => {
       await callback(txSql);
       throw void 0;
     });
   } catch {
   } finally {
-    await sql2.end();
+    await sql.end();
   }
 }
 
@@ -2405,8 +2405,8 @@ function aiProvider(options) {
       if (!_embedModel) _embedModel = client.embedding(m);
       return _embedModel;
     },
-    async embed(text2) {
-      const result = await aiEmbed({ model: this.embeddingModel(), value: text2 });
+    async embed(text) {
+      const result = await aiEmbed({ model: this.embeddingModel(), value: text });
       return result.embedding;
     },
     async embedMany(texts) {
@@ -2444,440 +2444,6 @@ import { openai, createOpenAI as createOpenAI2 } from "@ai-sdk/openai";
 
 // postgres/client.ts
 import postgresFactory from "postgres";
-
-// postgres/schema/sql.ts
-var SQL = class {
-  /** Template string parts (interleaved with values). */
-  strings;
-  /** Bound parameter values. */
-  values;
-  constructor(strings, values) {
-    this.strings = strings;
-    this.values = values;
-  }
-  /** Serialize to a raw SQL string (interpolating values inline for DDL use). */
-  toSQL() {
-    let result = "";
-    for (let i = 0; i < this.strings.length; i++) {
-      result += this.strings[i];
-      if (i < this.values.length) {
-        result += String(this.values[i]);
-      }
-    }
-    return result;
-  }
-};
-
-// postgres/schema/columns.ts
-function toDDL(col) {
-  const parts = [`"${col.name}"`, col.sqlType];
-  if (col.isPrimaryKey) parts.push("PRIMARY KEY");
-  if (!col.isPrimaryKey && !col.isNullable) parts.push("NOT NULL");
-  if (col.isUnique) parts.push("UNIQUE");
-  if (col.defaultExpr) parts.push(`DEFAULT ${col.defaultExpr}`);
-  if (col.ref) {
-    parts.push(`REFERENCES "${col.ref.table}"("${col.ref.column}")`);
-    if (col.ref.onDelete) parts.push(`ON DELETE ${col.ref.onDelete.toUpperCase()}`);
-  }
-  return parts.join(" ");
-}
-
-// postgres/schema/where.ts
-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 {
-  /** Database table name. */
-  tableName;
-  /** All column builders (order-preserving). */
-  columns;
-  /** Column builders keyed by property name. */
-  builders;
-  colEntries;
-  constructor(tableName, builders) {
-    this.tableName = tableName;
-    this.builders = builders;
-    this.columns = Object.values(builders);
-    this.colEntries = Object.entries(builders).map(([prop, col]) => ({
-      prop,
-      db: col.name,
-      auto: col.isAutoGenerate,
-      column: col
-    }));
-  }
-  /** Check if the table has a column with the given DB name. */
-  hasColumn(dbName) {
-    return this.colEntries.some((e) => e.db === dbName);
-  }
-  /**
-   * Bind this table schema to a SQL connection, returning a `BoundTable`
-   * that can run queries without passing `sql` to every call.
-   */
-  bind(sql2) {
-    return new BoundTable(sql2, this.tableName, this.builders);
-  }
-  /** Returns the primary key column name (DB name), or 'id' as fallback. */
-  get pkColumn() {
-    const entry = this.colEntries.find((e) => e.column.isPrimaryKey);
-    return entry ? entry.db : "id";
-  }
-  /** Adds `deleted_at IS NULL` condition if the table has soft delete and not explicitly excluded. */
-  _softDeleteFilter(where, opts) {
-    if (!this.hasColumn("deleted_at")) return null;
-    if (opts?.withDeleted) return null;
-    if (where && typeof where === "object" && !Array.isArray(where) && !(where instanceof SQL)) {
-      if ("deleted_at" in where) return null;
-    }
-    return '"deleted_at" IS NULL';
-  }
-  async create(sql2, opts) {
-    const colDDL = this.columns.map(toDDL);
-    let ddl = `CREATE TABLE IF NOT EXISTS "${this.tableName}" (
-  ${colDDL.join(",\n  ")}
-)`;
-    if (opts?.partitionBy) {
-      ddl += ` PARTITION BY ${opts.partitionBy.type} ("${opts.partitionBy.column}")`;
-    }
-    await sql2.unsafe(ddl);
-  }
-  async drop(sql2, opts) {
-    const cascade = opts?.cascade ? " CASCADE" : "";
-    await sql2.unsafe(`DROP TABLE IF EXISTS "${this.tableName}"${cascade}`);
-  }
-  async createIndex(sql2, columns, opts) {
-    const cols = Array.isArray(columns) ? columns : [columns];
-    const name = `"${this.tableName}_${cols.join("_")}${opts?.unique ? "_uidx" : "_idx"}"`;
-    const unique = opts?.unique ? "UNIQUE" : "";
-    const using = opts?.type ? `USING ${opts.type.toUpperCase()}` : "";
-    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);
-  }
-  async createUniqueIndex(sql2, columns) {
-    await this.createIndex(sql2, columns, { unique: true });
-  }
-  // --- Private helpers ---
-  _buildConditions(where, startIndex) {
-    const conditions = [];
-    const values = [];
-    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 += `$${startIndex + 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}" = $${startIndex + values.length + 1}`);
-        values.push(value);
-      }
-    }
-    return { conditions, values };
-  }
-  _buildSET(data) {
-    const sets = [];
-    const values = [];
-    const d = data;
-    for (const { prop, db } of this.colEntries) {
-      if (prop in d && d[prop] !== void 0) {
-        const val = d[prop];
-        if (val instanceof SQL) {
-          sets.push(`"${db}" = ${val.toSQL()}`);
-        } else {
-          sets.push(`"${db}" = $${sets.length + 1}`);
-          values.push(val);
-        }
-      }
-    }
-    if (this.hasColumn("updated_at") && !d.updated_at) {
-      sets.push('"updated_at" = NOW()');
-    }
-    return { sets, values };
-  }
-  // --- CRUD ---
-  async insert(sql2, data) {
-    const filtered = {};
-    for (const { prop, db, auto } of this.colEntries) {
-      if (auto) continue;
-      const val = data[prop];
-      if (val !== void 0) {
-        filtered[db] = val;
-      }
-    }
-    const [row] = await sql2`
-      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
-    `;
-    return row;
-  }
-  async insertMany(sql2, data) {
-    const filtered = [];
-    for (const item of data) {
-      const row = {};
-      for (const { prop, db, auto } of this.colEntries) {
-        if (auto) continue;
-        const val = item[prop];
-        if (val !== void 0) {
-          row[db] = val;
-        }
-      }
-      filtered.push(row);
-    }
-    const rows = await sql2`
-      INSERT INTO ${sql2(this.tableName)} ${sql2(filtered)} RETURNING *
-    `;
-    return rows;
-  }
-  async read(sql2, id, opts) {
-    const pk = this.pkColumn;
-    const columns = opts?.select?.length ? opts.select.map((c) => `"${c}"`).join(", ") : "*";
-    const softDel = this._softDeleteFilter(null, opts);
-    const extraAnd = softDel ? ` AND ${softDel}` : "";
-    const [row] = await sql2.unsafe(
-      `SELECT ${columns} FROM "${this.tableName}" WHERE "${pk}" = $1${extraAnd} LIMIT 1`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async readMany(sql2, where, opts) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    const softDel = this._softDeleteFilter(where, opts);
-    if (softDel) conditions.push(softDel);
-    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    const [countRow] = await sql2.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 sql2`SELECT * FROM ${sql2(this.tableName)}`;
-      return { count, data: rows2 };
-    }
-    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);
-        return `"${entry?.db || prop}" ${dir.toUpperCase()}`;
-      }).join(", ");
-      query += ` ORDER BY ${orders}`;
-    }
-    if (opts?.limit) query += ` LIMIT ${opts.limit}`;
-    if (opts?.offset) query += ` OFFSET ${opts.offset}`;
-    const rows = await sql2.unsafe(query, values);
-    return { count, data: rows };
-  }
-  async update(sql2, id, data) {
-    const { sets, values: setValues } = this._buildSET(data);
-    if (sets.length === 0) return void 0;
-    const pk = this.pkColumn;
-    const [row] = await sql2.unsafe(
-      `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE "${pk}" = $${setValues.length + 1} RETURNING *`,
-      [...setValues, id]
-    );
-    return row ?? void 0;
-  }
-  async updateMany(sql2, where, data) {
-    const { sets, values: setValues } = this._buildSET(data);
-    if (sets.length === 0) return 0;
-    const { conditions: wConditions, values: wValues } = this._buildConditions(
-      where,
-      setValues.length
-    );
-    if (wConditions.length === 0) return 0;
-    const rows = await sql2.unsafe(
-      `UPDATE "${this.tableName}" SET ${sets.join(", ")} WHERE ${wConditions.join(" AND ")} RETURNING 1`,
-      [...setValues, ...wValues]
-    );
-    return rows.length;
-  }
-  async delete(sql2, id) {
-    const pk = this.pkColumn;
-    if (this.hasColumn("deleted_at")) {
-      const [row2] = await sql2.unsafe(
-        `UPDATE "${this.tableName}" SET "deleted_at" = NOW() WHERE "${pk}" = $1 RETURNING *`,
-        [id]
-      );
-      return row2 ?? void 0;
-    }
-    const [row] = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE "${pk}" = $1 RETURNING *`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async hardDelete(sql2, id) {
-    const pk = this.pkColumn;
-    const [row] = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE "${pk}" = $1 RETURNING *`,
-      [id]
-    );
-    return row ?? void 0;
-  }
-  async deleteMany(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    if (conditions.length === 0) return 0;
-    if (this.hasColumn("deleted_at")) {
-      const rows2 = await sql2.unsafe(
-        `UPDATE "${this.tableName}" SET "deleted_at" = NOW() WHERE ${conditions.join(" AND ")} RETURNING 1`,
-        values
-      );
-      return rows2.length;
-    }
-    const rows = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`,
-      values
-    );
-    return rows.length;
-  }
-  async hardDeleteMany(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    if (conditions.length === 0) return 0;
-    const rows = await sql2.unsafe(
-      `DELETE FROM "${this.tableName}" WHERE ${conditions.join(" AND ")} RETURNING 1`,
-      values
-    );
-    return rows.length;
-  }
-  async upsert(sql2, data, conflict) {
-    const filtered = {};
-    for (const { prop, db, auto } of this.colEntries) {
-      if (auto) continue;
-      const val = data[prop];
-      if (val !== void 0) {
-        filtered[db] = val;
-      }
-    }
-    const keys = Object.keys(filtered);
-    if (keys.length === 0) throw new Error("upsert: no data to insert");
-    const conflictCols = Array.isArray(conflict) ? conflict : [conflict];
-    const dbCols = keys.map((c) => `"${c}"`);
-    const placeholders = keys.map((_, i) => `$${i + 1}`);
-    const updateSet = keys.filter((k) => !conflictCols.includes(k)).map((k) => `"${k}" = EXCLUDED."${k}"`).join(", ");
-    if (!updateSet) {
-      const [row2] = await sql2.unsafe(
-        `INSERT INTO "${this.tableName}" (${dbCols.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictCols.map((c) => `"${c}"`).join(", ")}) DO NOTHING RETURNING *`,
-        Object.values(filtered)
-      );
-      return row2 ?? void 0;
-    }
-    const [row] = await sql2.unsafe(
-      `INSERT INTO "${this.tableName}" (${dbCols.join(", ")}) VALUES (${placeholders.join(", ")}) ON CONFLICT (${conflictCols.map((c) => `"${c}"`).join(", ")}) DO UPDATE SET ${updateSet} RETURNING *`,
-      Object.values(filtered)
-    );
-    return row;
-  }
-  async count(sql2, where) {
-    const { conditions, values } = this._buildConditions(where, 0);
-    const softDel = this._softDeleteFilter(where);
-    if (softDel) conditions.push(softDel);
-    const whereClause = conditions.length > 0 ? ` WHERE ${conditions.join(" AND ")}` : "";
-    const [row] = await sql2.unsafe(
-      `SELECT COUNT(*) AS _total FROM "${this.tableName}"${whereClause}`,
-      values
-    );
-    return Number(row._total);
-  }
-};
-var BoundTable = class _BoundTable {
-  inner;
-  sql;
-  /** The underlying table name. */
-  get tableName() {
-    return this.inner.tableName;
-  }
-  constructor(sql2, tableName, builders) {
-    this.inner = new Table(tableName, builders);
-    this.sql = sql2;
-  }
-  async create(opts) {
-    await this.inner.create(this.sql, opts);
-  }
-  async drop(opts) {
-    await this.inner.drop(this.sql, opts);
-  }
-  async createIndex(columns, opts) {
-    await this.inner.createIndex(this.sql, columns, opts);
-  }
-  async createUniqueIndex(columns) {
-    await this.inner.createUniqueIndex(this.sql, columns);
-  }
-  async insert(data) {
-    return await this.inner.insert(this.sql, data);
-  }
-  async insertMany(data) {
-    return await this.inner.insertMany(this.sql, data);
-  }
-  async read(id, opts) {
-    return await this.inner.read(this.sql, id, opts);
-  }
-  async readMany(where, opts) {
-    return await this.inner.readMany(this.sql, where, opts);
-  }
-  async update(id, data) {
-    return await this.inner.update(this.sql, id, data);
-  }
-  async updateMany(where, data) {
-    return await this.inner.updateMany(this.sql, where, data);
-  }
-  async delete(id) {
-    return await this.inner.delete(this.sql, id);
-  }
-  async hardDelete(id) {
-    return await this.inner.hardDelete(this.sql, id);
-  }
-  async deleteMany(where) {
-    return await this.inner.deleteMany(this.sql, where);
-  }
-  async hardDeleteMany(where) {
-    return await this.inner.hardDeleteMany(this.sql, where);
-  }
-  async upsert(data, conflict) {
-    return await this.inner.upsert(this.sql, data, conflict);
-  }
-  async count(where) {
-    return await this.inner.count(this.sql, where);
-  }
-  withSql(sql2) {
-    return new _BoundTable(sql2, this.inner.tableName, this.inner.builders);
-  }
-};
-
-// postgres/client.ts
 var MIGRATIONS_TABLE = "_weifuwu_migrations";
 var RETRYABLE_CODES = /* @__PURE__ */ new Set(["40P01", "40001"]);
 function isRetryable(err) {
@@ -2897,7 +2463,7 @@ function postgres(opts) {
     const sep2 = connStr.includes("?") ? "&" : "?";
     connStr = `${connStr}${sep2}options=-c%20statement_timeout%3D${stmtTimeout}`;
   }
-  const sql2 = postgresFactory(connStr, {
+  const sql = postgresFactory(connStr, {
     max: options.max,
     ssl: options.ssl,
     idle_timeout: options.idle_timeout,
@@ -2907,7 +2473,7 @@ function postgres(opts) {
     options.signal.addEventListener(
       "abort",
       () => {
-        sql2.end();
+        sql.end();
       },
       { once: true }
     );
@@ -2917,19 +2483,13 @@ function postgres(opts) {
   const _waiting = 0;
   const poolMax = options.max ?? 10;
   const mw = ((req, ctx, next) => {
-    ctx.sql = sql2;
+    ctx.sql = sql;
     return next(req, ctx);
   });
   mw.__meta = { injects: ["sql"], depends: [] };
-  mw.sql = sql2;
-  mw.table = ((tableOrSchema, builders) => {
-    if (typeof tableOrSchema === "string") {
-      return new BoundTable(sql2, tableOrSchema, builders);
-    }
-    return new BoundTable(sql2, tableOrSchema.tableName, tableOrSchema.builders);
-  });
+  mw.sql = sql;
   mw.migrate = async () => {
-    await sql2.unsafe(`
+    await sql.unsafe(`
       CREATE TABLE IF NOT EXISTS "${MIGRATIONS_TABLE}" (
         name TEXT PRIMARY KEY,
         applied_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
@@ -2937,13 +2497,13 @@ function postgres(opts) {
     `);
   };
   mw.markMigrated = async (moduleName) => {
-    await sql2.unsafe(
+    await sql.unsafe(
       `INSERT INTO "${MIGRATIONS_TABLE}" (name) VALUES ($1) ON CONFLICT DO NOTHING`,
       [moduleName]
     );
   };
   mw.isMigrated = async (moduleName) => {
-    const [row] = await sql2.unsafe(`SELECT 1 FROM "${MIGRATIONS_TABLE}" WHERE name = $1`, [
+    const [row] = await sql.unsafe(`SELECT 1 FROM "${MIGRATIONS_TABLE}" WHERE name = $1`, [
       moduleName
     ]);
     return !!row;
@@ -2952,7 +2512,7 @@ function postgres(opts) {
     const maxRetries = retryOpts?.maxRetries ?? 3;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        const result = await sql2.begin(fn);
+        const result = await sql.begin(fn);
         return result;
       } catch (err) {
         if (attempt < maxRetries && isRetryable(err)) {
@@ -2971,7 +2531,7 @@ function postgres(opts) {
     waiting: _waiting,
     max: poolMax
   });
-  mw.close = () => sql2.end({ timeout: closeTimeout });
+  mw.close = () => sql.end({ timeout: closeTimeout });
   return mw;
 }
 
@@ -3214,7 +2774,7 @@ function createMemoryQueue(opts) {
   return q;
 }
 function createPgQueue(opts) {
-  const sql2 = opts.pg.sql;
+  const sql = opts.pg.sql;
   const pollInterval = opts?.pollInterval ?? 200;
   const table = (opts?.prefix ?? "queue") + "_jobs";
   const handlers = /* @__PURE__ */ new Map();
@@ -3224,10 +2784,10 @@ function createPgQueue(opts) {
   const MAX_FAILED = 1e3;
   async function ensureTable() {
     if (ready) return;
-    await sql2.unsafe(
+    await sql.unsafe(
       `CREATE TABLE IF NOT EXISTS ${escapeIdent(table)} (id UUID PRIMARY KEY, type TEXT NOT NULL, payload JSONB NOT NULL DEFAULT '{}', run_at TIMESTAMPTZ NOT NULL DEFAULT NOW(), schedule TEXT, status TEXT NOT NULL DEFAULT 'pending', error TEXT, failed_at TIMESTAMPTZ, created_at TIMESTAMPTZ NOT NULL DEFAULT NOW())`
     );
-    await sql2.unsafe(
+    await sql.unsafe(
       `CREATE INDEX IF NOT EXISTS ${escapeIdent(table + "_run_at_idx")} ON ${escapeIdent(table)} (run_at, status)`
     );
     ready = true;
@@ -3237,12 +2797,12 @@ function createPgQueue(opts) {
     try {
       await handler(job);
       _processed++;
-      await sql2.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id]);
+      await sql.unsafe(`DELETE FROM ${escapeIdent(table)} WHERE id = $1`, [job.id]);
     } catch (e) {
       _failed++;
       const msg = e.message;
       console.error("[queue] handler error:", msg);
-      await sql2.unsafe(
+      await sql.unsafe(
         `UPDATE ${escapeIdent(table)} SET status = 'failed', error = $2, failed_at = NOW() WHERE id = $1`,
         [job.id, msg]
       );
@@ -3252,7 +2812,7 @@ function createPgQueue(opts) {
     if (job.schedule) {
       try {
         const nextRun = cronNext(job.schedule);
-        await sql2.unsafe(
+        await sql.unsafe(
           `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
           [
             crypto4.randomUUID(),
@@ -3271,7 +2831,7 @@ function createPgQueue(opts) {
     if (!running) return;
     try {
       while (running && inflight < MAX_CONCURRENT) {
-        const rows = await sql2.unsafe(
+        const rows = await sql.unsafe(
           `UPDATE ${escapeIdent(table)} SET status = 'running' WHERE id = (SELECT id FROM ${escapeIdent(table)} WHERE run_at <= NOW() AND status = 'pending' ORDER BY run_at LIMIT 1 FOR UPDATE SKIP LOCKED) RETURNING *`
           // eslint-disable-next-line @typescript-eslint/no-explicit-any
         );
@@ -3319,7 +2879,7 @@ function createPgQueue(opts) {
       } else {
         runAt = /* @__PURE__ */ new Date();
       }
-      await sql2.unsafe(
+      await sql.unsafe(
         `INSERT INTO ${escapeIdent(table)} (id, type, payload, run_at, schedule) VALUES ($1, $2, $3::jsonb, $4, $5)`,
         [id, type, JSON.stringify(payload), runAt.toISOString(), opts2?.schedule || null]
       );
@@ -3345,7 +2905,7 @@ function createPgQueue(opts) {
     while (inflight > 0) await new Promise((r) => setTimeout(r, 50));
   };
   mw.jobs = async function jobs(limit) {
-    const rows = await sql2.unsafe(
+    const rows = await sql.unsafe(
       `SELECT * FROM ${escapeIdent(table)} WHERE status = 'pending' ORDER BY run_at LIMIT $1`,
       [limit ?? 50]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3360,7 +2920,7 @@ function createPgQueue(opts) {
     }));
   };
   mw.failedJobs = async function failedJobs(limit) {
-    const rows = await sql2.unsafe(
+    const rows = await sql.unsafe(
       `SELECT * FROM ${escapeIdent(table)} WHERE status = 'failed' ORDER BY failed_at DESC LIMIT $1`,
       [limit ?? 50]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3377,7 +2937,7 @@ function createPgQueue(opts) {
     }));
   };
   mw.retryFailed = async function retryFailed(jobId) {
-    const result = await sql2.unsafe(
+    const result = await sql.unsafe(
       `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE id = $1 AND status = 'failed' RETURNING id`,
       [jobId]
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3385,7 +2945,7 @@ function createPgQueue(opts) {
     return result.length > 0;
   };
   mw.retryAllFailed = async function retryAllFailed(type) {
-    const result = await sql2.unsafe(
+    const result = await sql.unsafe(
       type ? `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' AND type = $1 RETURNING id` : `UPDATE ${escapeIdent(table)} SET status = 'pending', error = NULL, failed_at = NULL, run_at = NOW() WHERE status = 'failed' RETURNING id`,
       type ? [type] : []
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -3454,14 +3014,14 @@ function createRedisQueue(opts) {
       while (running && inflight < MAX_CONCURRENT) {
         const result = await redis2.zpopmin(jobKey);
         if (result.length < 2) break;
-        const raw = result[0], score = parseInt(result[1], 10);
+        const raw2 = result[0], score = parseInt(result[1], 10);
         if (score > now) {
-          await redis2.zadd(jobKey, score, raw);
+          await redis2.zadd(jobKey, score, raw2);
           break;
         }
         let job;
         try {
-          job = JSON.parse(raw);
+          job = JSON.parse(raw2);
         } catch {
           continue;
         }
@@ -3511,8 +3071,8 @@ function createRedisQueue(opts) {
     redis2.disconnect();
   };
   mw.jobs = async function jobs(limit) {
-    const raw = await redis2.zrevrange(jobKey, 0, (limit ?? 50) - 1);
-    return raw.map((r) => {
+    const raw2 = await redis2.zrevrange(jobKey, 0, (limit ?? 50) - 1);
+    return raw2.map((r) => {
       try {
         return JSON.parse(r);
       } catch {
@@ -3521,8 +3081,8 @@ function createRedisQueue(opts) {
     }).filter(Boolean);
   };
   mw.failedJobs = async function failedJobs(limit) {
-    const raw = await redis2.lrange(failedKey, 0, (limit ?? 50) - 1);
-    return raw.map((r) => {
+    const raw2 = await redis2.lrange(failedKey, 0, (limit ?? 50) - 1);
+    return raw2.map((r) => {
       try {
         return JSON.parse(r);
       } catch {
@@ -3531,8 +3091,8 @@ function createRedisQueue(opts) {
     }).filter(Boolean);
   };
   mw.retryFailed = async function retryFailed(jobId) {
-    const raw = await redis2.lrange(failedKey, 0, -1);
-    for (const entry of raw) {
+    const raw2 = await redis2.lrange(failedKey, 0, -1);
+    for (const entry of raw2) {
       try {
         const job = JSON.parse(entry);
         if (job.id === jobId) {
@@ -3551,8 +3111,8 @@ function createRedisQueue(opts) {
   };
   mw.retryAllFailed = async function retryAllFailed(type) {
     let count = 0;
-    const raw = await redis2.lrange(failedKey, 0, -1);
-    for (const entry of raw) {
+    const raw2 = await redis2.lrange(failedKey, 0, -1);
+    for (const entry of raw2) {
       try {
         const job = JSON.parse(entry);
         if (type && job.type !== type) continue;
@@ -3802,14 +3362,14 @@ function makeSetFlash(name, location) {
 function flash(options) {
   const name = options?.name ?? "flash";
   const mw = async (req, ctx, next) => {
-    const raw = getCookies(req)[name] ?? null;
+    const raw2 = getCookies(req)[name] ?? null;
     const referer = req.headers.get("referer") || "/";
     let value = void 0;
-    if (raw) {
+    if (raw2) {
       try {
-        value = JSON.parse(decodeURIComponent(raw));
+        value = JSON.parse(decodeURIComponent(raw2));
       } catch {
-        value = raw;
+        value = raw2;
       }
     }
     ctx.flash = {
@@ -3817,7 +3377,7 @@ function flash(options) {
       set: makeSetFlash(name, referer)
     };
     const res = await next(req, ctx);
-    if (raw) {
+    if (raw2) {
       const headers = new Headers(res.headers);
       headers.append("Set-Cookie", `${name}=; Path=/; Max-Age=0`);
       return new Response(res.body, { status: res.status, statusText: res.statusText, headers });
@@ -3874,6 +3434,255 @@ function csrf(options) {
   mw.__meta = { injects: ["csrf"], depends: [] };
   return mw;
 }
+
+// ssr/html.ts
+var ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function escapeHtml(s) {
+  const str = String(s);
+  if (!/[&<>"']/.test(str)) return str;
+  return str.replace(/[&<>"']/g, (c) => ESCAPE_MAP[c] || c);
+}
+function raw(s) {
+  return {
+    __brand: "RawString",
+    value: s,
+    toString() {
+      return this.value;
+    }
+  };
+}
+function isRaw(v) {
+  return typeof v === "object" && v !== null && "__brand" in v && v.__brand === "RawString";
+}
+function html(strings, ...values) {
+  let result = "";
+  for (let i = 0; i < strings.length; i++) {
+    result += strings[i];
+    if (i < values.length) {
+      result += stringify(values[i]);
+    }
+  }
+  return raw(result);
+}
+function stringify(v) {
+  if (v === null || v === void 0 || v === false) return "";
+  if (isRaw(v)) return v.value;
+  if (Array.isArray(v)) {
+    let out = "";
+    for (let i = 0; i < v.length; i++) {
+      out += stringify(v[i]);
+    }
+    return out;
+  }
+  if (typeof v === "number") return String(v);
+  return escapeHtml(v);
+}
+
+// ssr/layout.ts
+import { resolve as resolve4, isAbsolute } from "node:path";
+function layout(path) {
+  const absPath = isAbsolute(path) ? path : resolve4(process.cwd(), path);
+  let modPromise = null;
+  async function getRenderFn() {
+    if (!modPromise) {
+      modPromise = import(absPath).catch((err) => {
+        modPromise = null;
+        throw new Error(
+          `[layout] Failed to load layout module "${path}": ${err instanceof Error ? err.message : String(err)}`
+        );
+      });
+    }
+    const mod = await modPromise;
+    const renderFn = mod.default;
+    if (typeof renderFn !== "function") {
+      throw new Error(
+        `[layout] Layout module "${path}" must export a default function, got ${typeof renderFn}`
+      );
+    }
+    return renderFn;
+  }
+  const mw = async (req, ctx, next) => {
+    const renderFn = await getRenderFn();
+    const response = await next(req, ctx);
+    const ct = response.headers.get("content-type") ?? "";
+    if (!ct.includes("text/html")) return response;
+    const body = await response.text();
+    const wrapped = await renderFn(body, ctx);
+    return new Response(wrapped, {
+      status: response.status,
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  };
+  mw.__meta = { injects: [], depends: [] };
+  return mw;
+}
+
+// ssr/compile.ts
+import { resolve as resolve5, isAbsolute as isAbsolute2 } from "node:path";
+var moduleCache = /* @__PURE__ */ new Map();
+var loading = /* @__PURE__ */ new Map();
+async function loadModule(path) {
+  const absPath = isAbsolute2(path) ? path : resolve5(process.cwd(), path);
+  const cached = moduleCache.get(absPath);
+  if (cached) return cached;
+  const inFlight = loading.get(absPath);
+  if (inFlight) return inFlight;
+  const promise = import(absPath).then((mod) => {
+    loading.delete(absPath);
+    moduleCache.set(absPath, Promise.resolve(mod));
+    return mod;
+  }).catch((err) => {
+    loading.delete(absPath);
+    moduleCache.delete(absPath);
+    throw new Error(
+      `[compile] Failed to load module "${path}": ${err instanceof Error ? err.message : String(err)}`
+    );
+  });
+  loading.set(absPath, promise);
+  return promise;
+}
+function clearModuleCache(path) {
+  if (path) {
+    const absPath = isAbsolute2(path) ? path : resolve5(process.cwd(), path);
+    moduleCache.delete(absPath);
+    loading.delete(absPath);
+  } else {
+    moduleCache.clear();
+    loading.clear();
+  }
+}
+
+// ssr/view.ts
+function isRawString(v) {
+  return typeof v === "object" && v !== null && "__brand" in v && v.__brand === "RawString";
+}
+function isResponse(v) {
+  return v instanceof Response;
+}
+function view(path, options) {
+  return async (req, ctx) => {
+    let mod;
+    if (options?.module) {
+      mod = options.module;
+    } else {
+      mod = await loadModule(path);
+    }
+    const renderFn = mod.default;
+    if (typeof renderFn !== "function") {
+      throw new Error(
+        `[view] Module "${path}" must export a default function, got ${typeof renderFn}`
+      );
+    }
+    const result = renderFn.length >= 1 ? await renderFn(ctx) : await renderFn();
+    if (isResponse(result)) return result;
+    const body = isRawString(result) ? result.value : String(result);
+    return new Response(body, {
+      status: 200,
+      headers: { "content-type": "text/html; charset=utf-8" }
+    });
+  };
+}
+
+// ssr/css.ts
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync as readFileSync2 } from "node:fs";
+import { join as join3, resolve as resolve6 } from "node:path";
+import tailwindPlugin from "@tailwindcss/postcss";
+import postcss from "postcss";
+var cssCache = /* @__PURE__ */ new Map();
+async function compileCSS(cssPath, sourceDir) {
+  if (!existsSync(cssPath)) {
+    return { css: "", hash: "empty", url: "" };
+  }
+  const raw2 = readFileSync2(cssPath, "utf-8");
+  const src = `@source "${sourceDir}";
+${raw2}`;
+  const result = await postcss([tailwindPlugin()]).process(src, { from: cssPath });
+  const hash = createHash("md5").update(result.css).digest("hex").slice(0, 8);
+  const asset = { css: result.css, hash, url: `/__wfw/style/${hash}.css` };
+  cssCache.set(cssPath, asset);
+  return asset;
+}
+function cssContext(dir) {
+  const appDir = resolve6(dir, "app");
+  const cssPath = join3(appDir, "globals.css");
+  let cached = null;
+  return async (req, ctx, next) => {
+    if (!cached) cached = compileCSS(cssPath, appDir);
+    const asset = await cached;
+    if (asset.css) ctx.css = asset;
+    return next(req, ctx);
+  };
+}
+function cssRouter(dir) {
+  const router = new Router();
+  router.get("/__wfw/style/:hash.css", async () => {
+    const cssPath = join3(resolve6(dir, "app"), "globals.css");
+    const asset = cssCache.get(cssPath);
+    if (!asset) return new Response("", { status: 404 });
+    return new Response(asset.css, {
+      headers: { "content-type": "text/css; charset=utf-8" }
+    });
+  });
+  return router;
+}
+function clearCSSCache() {
+  cssCache.clear();
+}
+
+// ssr/assets.ts
+import { readFileSync as readFileSync3 } from "node:fs";
+import { resolve as resolve7 } from "node:path";
+function resolvePackage(name, file) {
+  return resolve7(process.cwd(), "node_modules", name, file);
+}
+var HTMX_PATH = resolvePackage("htmx.org", "dist/htmx.min.js");
+var ALPINE_PATH = resolvePackage("alpinejs", "dist/cdn.min.js");
+var htmxContent = null;
+var alpineContent = null;
+function loadAsset(path) {
+  try {
+    return readFileSync3(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function assetRouter() {
+  const router = new Router();
+  router.get("/__wfw/js/htmx.min.js", () => {
+    if (!htmxContent) htmxContent = loadAsset(HTMX_PATH);
+    if (!htmxContent) return new Response("HTMX not found", { status: 404 });
+    return new Response(htmxContent, {
+      headers: {
+        "content-type": "application/javascript; charset=utf-8",
+        "cache-control": "public, max-age=31536000, immutable"
+      }
+    });
+  });
+  router.get("/__wfw/js/alpine.min.js", () => {
+    if (!alpineContent) alpineContent = loadAsset(ALPINE_PATH);
+    if (!alpineContent) return new Response("Alpine not found", { status: 404 });
+    return new Response(alpineContent, {
+      headers: {
+        "content-type": "application/javascript; charset=utf-8",
+        "cache-control": "public, max-age=31536000, immutable"
+      }
+    });
+  });
+  return router;
+}
+function assetScripts() {
+  return raw(`
+<script src="/__wfw/js/htmx.min.js"></script>
+<script defer src="/__wfw/js/alpine.min.js"></script>
+`);
+}
 export {
   DEFAULT_MAX_BODY,
   HttpError,
@@ -3883,6 +3692,10 @@ export {
   TestRequest,
   aiProvider,
   aiStream,
+  assetRouter,
+  assetScripts,
+  clearCSSCache,
+  clearModuleCache,
   compress,
   cors,
   createHub,
@@ -3891,6 +3704,8 @@ export {
   createTestDb,
   createTestServer,
   csrf,
+  cssContext,
+  cssRouter,
   currentTrace,
   currentTraceId,
   deleteCookie,
@@ -3907,16 +3722,20 @@ export {
   graphql,
   health,
   helmet,
+  html,
   i18n,
   isBundled,
   isDev,
   isProd,
+  layout,
   loadEnv,
+  loadModule,
   logger,
   openai,
   postgres,
   queue,
   rateLimit,
+  raw,
   redis,
   requestId,
   runWithTrace,
@@ -3933,5 +3752,6 @@ export {
   traceElapsed,
   upload,
   validate,
+  view,
   withTestDb
 };