exoagent 0.0.1 → 0.0.2

package/dist/sql.mjs

@@ -0,0 +1,553 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _desc_dec, _asc_dec, ___dec, ___dec2, ___dec3, ___dec4, ___dec5, _NOT_LIKE_dec, _LIKE_dec, ____dec, ____dec2, ___dec6, ____dec3, ___dec7, ____dec4, ___dec8, _isNotNull_dec, _isNull_dec, _not_dec, _and_dec, _or_dec, _a, _init, _execute_dec, _join_dec, _offset_dec, _limit_dec, _orderBy_dec, _where_dec, _select_dec, _b, _db, _limit, _offset, _init2;
+import { sql as sql$1, Kysely } from "kysely";
+import invariant from "tiny-invariant";
+import z from "zod";
+import { R as RpcToolset, t as tool, s as setToolMetadata } from "./rpc-toolset-BnC2BXPq.js";
+const sql = sql$1;
+const buildSql = (parts, separator = sql$1` `) => {
+  return sql$1.join(parts.filter((x) => x != null), separator);
+};
+const asSqlExpression = (value) => {
+  return value instanceof SqlExpression ? value : new LiteralExpression(value);
+};
+const isSqlExpressionIn = (value) => {
+  return typeof value === "number" || typeof value === "string" || typeof value === "boolean" || value === null || value === void 0 || value instanceof SqlExpression;
+};
+const zSqlExpression = z.custom((val) => val instanceof SqlExpression);
+const zNumericSqlExpression = z.union([zSqlExpression, z.number(), z.string()]);
+const zSqlExpressionIn = z.union([zSqlExpression, z.number(), z.string(), z.boolean(), z.null()]);
+class SqlExpression extends (_a = RpcToolset, _or_dec = [tool(zSqlExpression)], _and_dec = [tool(zSqlExpression)], _not_dec = [tool()], _isNull_dec = [tool()], _isNotNull_dec = [tool()], ___dec8 = [tool(zNumericSqlExpression)], ____dec4 = [tool(zNumericSqlExpression)], ___dec7 = [tool(zNumericSqlExpression)], ____dec3 = [tool(zNumericSqlExpression)], ___dec6 = [tool(zSqlExpressionIn)], ____dec2 = [tool(zSqlExpressionIn)], ____dec = [tool(zSqlExpressionIn)], _LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], _NOT_LIKE_dec = [tool(z.union([zSqlExpression, z.string()]))], ___dec5 = [tool(zNumericSqlExpression)], ___dec4 = [tool(zNumericSqlExpression)], ___dec3 = [tool(zNumericSqlExpression)], ___dec2 = [tool(zNumericSqlExpression)], ___dec = [tool(zNumericSqlExpression)], _asc_dec = [tool()], _desc_dec = [tool()], _a) {
+  constructor(precedence = 100) {
+    super();
+    __runInitializers(_init, 5, this);
+    // `= () => ` to ensure the method is a direct property of the class instance,
+    // not a method of the class prototype
+    __publicField(this, "compile", () => {
+      throw new Error("Not implemented");
+    });
+    this.precedence = precedence;
+  }
+  or(expr) {
+    return new BinaryExpression(this, expr, sql`OR`, 1);
+  }
+  and(expr) {
+    return new BinaryExpression(this, expr, sql`AND`, 2);
+  }
+  not() {
+    return new UnaryExpression(this, sql`NOT`, "prefix", 3);
+  }
+  isNull() {
+    return new UnaryExpression(this, sql`IS NULL`, "postfix", 4);
+  }
+  isNotNull() {
+    return new UnaryExpression(this, sql`IS NOT NULL`, "postfix", 4);
+  }
+  "<"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`<`, 5);
+  }
+  "<="(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`<=`, 5);
+  }
+  ">"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`>`, 5);
+  }
+  ">="(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`>=`, 5);
+  }
+  "="(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`=`, 5);
+  }
+  "<>"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`<>`, 5);
+  }
+  "!="(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`!=`, 5);
+  }
+  "LIKE"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`LIKE`, 6);
+  }
+  "NOT LIKE"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`NOT LIKE`, 6);
+  }
+  "+"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`+`, 8);
+  }
+  "-"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`-`, 8);
+  }
+  "*"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`*`, 9);
+  }
+  "/"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`/`, 9);
+  }
+  "%"(expr) {
+    return new BinaryExpression(this, asSqlExpression(expr), sql`%`, 9);
+  }
+  asc() {
+    return new OrderByValue(this, sql`ASC`);
+  }
+  desc() {
+    return new OrderByValue(this, sql`DESC`);
+  }
+}
+_init = __decoratorStart(_a);
+__decorateElement(_init, 1, "or", _or_dec, SqlExpression);
+__decorateElement(_init, 1, "and", _and_dec, SqlExpression);
+__decorateElement(_init, 1, "not", _not_dec, SqlExpression);
+__decorateElement(_init, 1, "isNull", _isNull_dec, SqlExpression);
+__decorateElement(_init, 1, "isNotNull", _isNotNull_dec, SqlExpression);
+__decorateElement(_init, 1, "<", ___dec8, SqlExpression);
+__decorateElement(_init, 1, "<=", ____dec4, SqlExpression);
+__decorateElement(_init, 1, ">", ___dec7, SqlExpression);
+__decorateElement(_init, 1, ">=", ____dec3, SqlExpression);
+__decorateElement(_init, 1, "=", ___dec6, SqlExpression);
+__decorateElement(_init, 1, "<>", ____dec2, SqlExpression);
+__decorateElement(_init, 1, "!=", ____dec, SqlExpression);
+__decorateElement(_init, 1, "LIKE", _LIKE_dec, SqlExpression);
+__decorateElement(_init, 1, "NOT LIKE", _NOT_LIKE_dec, SqlExpression);
+__decorateElement(_init, 1, "+", ___dec5, SqlExpression);
+__decorateElement(_init, 1, "-", ___dec4, SqlExpression);
+__decorateElement(_init, 1, "*", ___dec3, SqlExpression);
+__decorateElement(_init, 1, "/", ___dec2, SqlExpression);
+__decorateElement(_init, 1, "%", ___dec, SqlExpression);
+__decorateElement(_init, 1, "asc", _asc_dec, SqlExpression);
+__decorateElement(_init, 1, "desc", _desc_dec, SqlExpression);
+__decoratorMetadata(_init, SqlExpression);
+class BinaryExpression extends SqlExpression {
+  constructor(left, right, operator, precedence) {
+    super(precedence ?? 100);
+    this.left = left;
+    this.right = right;
+    this.operator = operator;
+  }
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  compile = () => {
+    const leftCompiled = this.left.compile();
+    const rightCompiled = this.right.compile();
+    return buildSql([
+      this.precedence > this.left.precedence ? sql`(${leftCompiled})` : leftCompiled,
+      this.operator,
+      this.precedence > this.right.precedence ? sql`(${rightCompiled})` : rightCompiled
+    ]);
+  };
+}
+class UnaryExpression extends SqlExpression {
+  constructor(operand, operator, placement, precedence) {
+    super(precedence ?? 100);
+    this.operand = operand;
+    this.operator = operator;
+    this.placement = placement;
+  }
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  compile = () => {
+    const operandCompiled = this.operand.compile();
+    const wrappedOperand = this.precedence > this.operand.precedence ? sql`(${operandCompiled})` : operandCompiled;
+    return this.placement === "postfix" ? buildSql([wrappedOperand, this.operator]) : buildSql([this.operator, wrappedOperand]);
+  };
+}
+class ColumnReferenceExpression extends SqlExpression {
+  constructor(alias, column) {
+    super();
+    this.alias = alias;
+    this.column = column;
+  }
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  compile = () => {
+    return sql.ref(`${this.alias}.${this.column}`);
+  };
+}
+class UnboundColumnReferenceExpression extends ColumnReferenceExpression {
+  constructor(alias, column) {
+    super(alias, column);
+    this.alias = alias;
+    this.column = column;
+  }
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  compile = () => {
+    throw new Error("Unbound column reference cannot be compiled");
+  };
+}
+class LiteralExpression extends SqlExpression {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  compile = () => {
+    return sql`${this.value}`;
+  };
+}
+class OrderByValue {
+  constructor(value, direction) {
+    this.value = value;
+    this.direction = direction;
+  }
+}
+const safeAliasRegex = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+const isSafeAlias = (value) => {
+  return safeAliasRegex.test(value) && !(value === "constructor" || value === "prototype" || value === "__proto__") && !(value in Object.prototype) && value !== "toJSON";
+};
+const assertSafeAlias = (value) => {
+  if (!isSafeAlias(value)) {
+    throw new Error(`Alias must be a safe alias: "${value}" does not match the regex ${safeAliasRegex.source}`);
+  }
+};
+const asRowLike = (value) => {
+  if (value instanceof TableBase) {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, value2]) => [key, asSqlExpression(value2)]));
+};
+const isRowLikeRawIn = (value) => {
+  return typeof value === "object" && value !== null && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null) && Object.entries(value).every(([key, value2]) => {
+    assertSafeAlias(key);
+    return typeof key === "string" && isSqlExpressionIn(value2);
+  });
+};
+const isRowLikeIn = (value) => {
+  return isRowLikeRawIn(value) || value instanceof TableBase;
+};
+const rowLikeRawEntries = (value) => {
+  const entries = [];
+  const myKeys = Object.keys(value);
+  const protoKeys = [];
+  if (value instanceof TableBase) {
+    let proto = Object.getPrototypeOf(value);
+    while (proto != null && proto !== TableBase.prototype) {
+      protoKeys.push(...Object.keys(proto));
+      proto = Object.getPrototypeOf(proto);
+    }
+  }
+  for (const key of /* @__PURE__ */ new Set([...myKeys, ...protoKeys])) {
+    const v = value[key];
+    if (v instanceof SqlExpression) {
+      entries.push([key, v]);
+    }
+  }
+  return entries;
+};
+const isTableClass = (value) => {
+  return typeof value === "function" && value.prototype instanceof TableBase;
+};
+const isFromItem = (value) => {
+  return value instanceof QueryBuilder || isTableClass(value);
+};
+const combinePredicates = (...predicates) => {
+  const filtered = predicates.filter((p) => p != null);
+  if (filtered.length === 0) {
+    return void 0;
+  }
+  return filtered.reduce((acc, predicate) => acc.and(predicate));
+};
+const namespacedArg = (tables) => {
+  return Object.fromEntries(Object.entries(tables).map(([k, v]) => [k, v.fromItem.toRowLike()]));
+};
+const _QueryBuilder = class _QueryBuilder extends (_b = RpcToolset, _select_dec = [tool.callback()], _where_dec = [tool.callback()], _orderBy_dec = [tool.callback()], _limit_dec = [tool(z.number().int().nonnegative())], _offset_dec = [tool(z.number().int().nonnegative())], _join_dec = [tool.unsafeNoValidation()], _execute_dec = [tool()], _b) {
+  // set only when created directly from a TableClass
+  constructor(params) {
+    super();
+    __runInitializers(_init2, 5, this);
+    __privateAdd(this, _db);
+    __publicField(this, "alias");
+    __publicField(this, "selectRowLike");
+    __publicField(this, "tables");
+    __publicField(this, "whereExpression");
+    __publicField(this, "orderByExpressions");
+    __privateAdd(this, _limit);
+    __privateAdd(this, _offset);
+    __publicField(this, "arg");
+    __publicField(this, "rawTable");
+    // Note, we use `= () => ` to ensure the method is a direct property of the class instance,
+    // not a method of the class prototype
+    __publicField(this, "paramsForCopy", () => {
+      return {
+        alias: this.alias,
+        tables: this.tables,
+        selectRowLike: this.selectRowLike,
+        whereExpression: this.whereExpression,
+        orderByExpressions: this.orderByExpressions,
+        limit: __privateGet(this, _limit),
+        offset: __privateGet(this, _offset),
+        db: __privateGet(this, _db),
+        // `rawTable` is set only when created directly from a TableClass
+        rawTable: void 0
+      };
+    });
+    __publicField(this, "toRowLike", () => {
+      if (this.selectRowLike instanceof TableBase) {
+        const tableClass = this.selectRowLike.constructor;
+        return tableClass.as(this.alias).toRowLike({ remapColumns: true });
+      }
+      return Object.fromEntries(Object.keys(this.selectRowLike).map((key) => [key, new ColumnReferenceExpression(this.alias, key)]));
+    });
+    __publicField(this, "compile", (opts) => {
+      const { tables, selectRowLike, whereExpression, orderByExpressions } = this;
+      const tablesList = Object.entries(tables);
+      const [[_, baseTable], ...rest] = tablesList.filter(([alias, table2]) => {
+        invariant(table2.fromItem.alias === alias, `Alias mismatch: ${table2.fromItem.alias} !== ${alias}`);
+        return table2.joinType === null;
+      });
+      const joins = tablesList.filter(([, table2]) => table2.joinType !== null);
+      invariant(baseTable, "Base table not found");
+      invariant(rest.length === 0, "Implicit joins not supported");
+      invariant(Object.keys(selectRowLike).length > 0, "select must return a non-empty row");
+      const combinedWhere = combinePredicates(whereExpression, baseTable.fromItem.onExpression);
+      const result = buildSql([
+        sql`SELECT ${buildSql(rowLikeRawEntries(selectRowLike).map(([key, value]) => sql`${value.compile()} as ${sql.ref(key)}`), sql`, `)}`,
+        sql`FROM ${baseTable.fromItem.compile({ isSubquery: true })}`,
+        ...joins.map(([, table2]) => buildSql([table2.joinType === "inner" ? sql`JOIN` : table2.joinType === "left" ? sql`LEFT JOIN` : null, table2.isLateral ? sql`LATERAL` : null, table2.fromItem.compile({ isSubquery: true }), table2.on ? sql`ON ${table2.on.compile()}` : null]), sql` `),
+        combinedWhere ? sql`WHERE ${combinedWhere.compile()}` : null,
+        orderByExpressions && orderByExpressions.length > 0 ? sql`ORDER BY ${buildSql(orderByExpressions.map((expr) => buildSql([expr.value.compile(), expr.direction])), sql`, `)}` : null,
+        __privateGet(this, _limit) != null ? sql`LIMIT ${__privateGet(this, _limit)}` : null,
+        __privateGet(this, _offset) != null ? sql`OFFSET ${__privateGet(this, _offset)}` : null
+      ]);
+      return opts?.isSubquery ? sql`(${result}) AS ${sql.ref(this.alias)}` : result;
+    });
+    __privateSet(this, _db, params.db);
+    this.alias = params.alias;
+    this.selectRowLike = params.selectRowLike;
+    this.tables = params.tables;
+    this.whereExpression = params.whereExpression;
+    this.orderByExpressions = params.orderByExpressions;
+    this.arg = namespacedArg(params.tables);
+    __privateSet(this, _limit, params.limit);
+    __privateSet(this, _offset, params.offset);
+    this.rawTable = params.rawTable;
+  }
+  select(select) {
+    const selectUnwrapped = tool.unwrap(select, isRowLikeIn);
+    return selectUnwrapped(this.arg, (result) => {
+      return new _QueryBuilder({ ...this.paramsForCopy(), selectRowLike: asRowLike(result) });
+    });
+  }
+  where(where) {
+    const whereUnwrapped = tool.unwrap(where, isSqlExpressionIn);
+    return whereUnwrapped(this.arg, (result) => {
+      return new _QueryBuilder({ ...this.paramsForCopy(), whereExpression: combinePredicates(this.whereExpression, asSqlExpression(result)) });
+    });
+  }
+  orderBy(orderBy) {
+    const orderByUnwrapped = tool.unwrap(orderBy, (arg) => {
+      if (Array.isArray(arg)) {
+        return arg.every((e) => e instanceof SqlExpression || e instanceof OrderByValue);
+      }
+      return arg instanceof SqlExpression || arg instanceof OrderByValue;
+    });
+    return orderByUnwrapped(this.arg, (raw) => {
+      const rawArray = Array.isArray(raw) ? raw : [raw];
+      const exprs = rawArray.map((e) => {
+        invariant(e instanceof SqlExpression || e instanceof OrderByValue, "orderBy must return a SqlExpression/OrderByValue or an array of SqlExpressions/OrderByValues");
+        return e instanceof SqlExpression ? new OrderByValue(e) : e;
+      });
+      return new _QueryBuilder({ ...this.paramsForCopy(), orderByExpressions: (this.orderByExpressions ?? []).concat(exprs) });
+    });
+  }
+  limit(limit) {
+    invariant(typeof limit === "number" && limit >= 0, "limit must be greater than or equal to 0");
+    return new _QueryBuilder({ ...this.paramsForCopy(), limit: Math.min(limit, __privateGet(this, _limit) ?? Infinity) });
+  }
+  offset(offset) {
+    invariant(typeof offset === "number" && offset >= 0, "offset must be greater than or equal to 0");
+    return new _QueryBuilder({ ...this.paramsForCopy(), offset: (__privateGet(this, _offset) ?? 0) + offset });
+  }
+  join(fromItem, on) {
+    const fromItemCallbackRaw = isFromItem(fromItem) ? () => fromItem : fromItem;
+    const fromItemCallback = tool.unwrap(fromItemCallbackRaw, isFromItem);
+    const res = fromItemCallback(this.arg, (fromItemResolved) => {
+      if (fromItemResolved instanceof _QueryBuilder && fromItemResolved.rawTable) {
+        fromItemResolved = fromItemResolved.rawTable;
+      }
+      const alias = fromItemResolved.alias;
+      if (this.tables[alias]) {
+        throw new Error(`Join already exists: ${alias} in ${Object.keys(this.tables)}`);
+      }
+      const arg = {
+        ...this.arg,
+        [alias]: fromItemResolved.toRowLike()
+      };
+      const onCallback = tool.unwrap(on ?? (() => void 0), (raw) => raw === void 0 || isSqlExpressionIn(raw));
+      return onCallback(arg, (onRaw) => {
+        const onResolved = combinePredicates(onRaw !== void 0 ? asSqlExpression(onRaw) : void 0, fromItemResolved.onExpression);
+        invariant(onResolved != null, "Must specify an `on` expression or use `Table.on` to set the on expression");
+        invariant(onResolved instanceof SqlExpression, "on must return a SqlExpression");
+        const tablesWithAlias = {
+          ...this.tables,
+          [alias]: {
+            fromItem: fromItemResolved,
+            on: onResolved,
+            joinType: "inner",
+            // If `fromItem` is a function that returns a QueryBuilder, it is implicitly a lateral join (depends on the other tables)
+            isLateral: !isFromItem(fromItem) && fromItemResolved instanceof _QueryBuilder
+          }
+        };
+        return new _QueryBuilder({ ...this.paramsForCopy(), tables: tablesWithAlias });
+      });
+    });
+    return res;
+  }
+  async execute() {
+    return await __privateGet(this, _db).execute(this.compile());
+  }
+};
+_init2 = __decoratorStart(_b);
+_db = new WeakMap();
+_limit = new WeakMap();
+_offset = new WeakMap();
+__decorateElement(_init2, 1, "select", _select_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "where", _where_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "orderBy", _orderBy_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "limit", _limit_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "offset", _offset_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "join", _join_dec, _QueryBuilder);
+__decorateElement(_init2, 1, "execute", _execute_dec, _QueryBuilder);
+__decoratorMetadata(_init2, _QueryBuilder);
+let QueryBuilder = _QueryBuilder;
+class TableBase extends RpcToolset {
+  opts;
+  // `= () => ` to ensure the method is a direct property of the class instance,
+  // not a method of the class prototype
+  column = function(columnName) {
+    const cls = this.constructor;
+    return new UnboundColumnReferenceExpression(cls.alias ?? cls.tableName, columnName);
+  };
+}
+const table = (db, name) => {
+  const { [name]: tableClass } = { [name]: class extends TableBase {
+    static tableName = name;
+    static alias = name;
+    static onExpression;
+    constructor(opts) {
+      super();
+      this.opts = opts;
+    }
+    static from() {
+      const tables = { [this.alias]: { fromItem: this, joinType: null, isLateral: false } };
+      return new QueryBuilder({ db, alias: this.alias, tables, selectRowLike: this.toRowLike(), rawTable: this });
+    }
+    static as(alias) {
+      assertSafeAlias(alias);
+      class Ret extends this {
+        static alias = alias;
+      }
+      return Ret;
+    }
+    static on(on) {
+      const Base = this;
+      return class extends Base {
+        static onExpression = combinePredicates(Base.onExpression, on(Base.toRowLike()));
+      };
+    }
+    // use `function` to bind `this` to the current class instance
+    static toRowLike = function(opts) {
+      const rowLike = new this(opts);
+      for (const key of Object.keys(rowLike)) {
+        const value = rowLike[key];
+        if (value instanceof UnboundColumnReferenceExpression) {
+          const proto = Object.getPrototypeOf(rowLike);
+          const getter = function() {
+            const cls = this.constructor;
+            return new ColumnReferenceExpression(cls.alias ?? cls.tableName, this.opts?.remapColumns ? key : value.column);
+          };
+          setToolMetadata(getter, { runtimeValidationEnabled: true });
+          Object.defineProperty(proto, key, {
+            get: getter,
+            enumerable: true,
+            configurable: true
+          });
+          delete rowLike[key];
+        }
+      }
+      return rowLike;
+    };
+    static compile = function() {
+      return sql`${sql.ref(this.tableName)} AS ${sql.ref(this.alias ?? this.tableName)}`;
+    };
+  } };
+  return tableClass;
+};
+class Database {
+  constructor(dialect, opts) {
+    this.dialect = dialect;
+    this.opts = opts;
+  }
+  kysely;
+  async execute(query) {
+    if (this.kysely == null) {
+      this.kysely = new Kysely({ dialect: this.dialect });
+    }
+    if (this.opts?.logQuery) {
+      this.opts.logQuery(query.compile(this.kysely));
+    }
+    const result = await query.execute(this.kysely);
+    if (this.opts?.returnExecutedQuery) {
+      const compiled = query.compile(this.kysely);
+      return {
+        results: result.rows,
+        sql: compiled.sql,
+        parameters: compiled.parameters
+      };
+    }
+    return { results: result.rows };
+  }
+  Table(name) {
+    return table(this, name);
+  }
+}
+export {
+  Database
+};

package/dist/stream-transport.d.ts

@@ -0,0 +1,11 @@
+import { RpcTransport } from '../packages/capnweb/dist';
+export declare class StreamTransport implements RpcTransport {
+    private input;
+    private output;
+    private bufferReader;
+    private writer;
+    constructor(input: ReadableStream<Uint8Array>, output: WritableStream<Uint8Array>);
+    send(message: string): Promise<void>;
+    receive(): Promise<string>;
+    abort(reason: unknown): void;
+}

package/dist/tool-wrapper.d.ts

@@ -0,0 +1,16 @@
+import { Tool, ToolExecutionOptions } from 'ai';
+import { RpcToolset } from './rpc-toolset';
+export type WrappableTools = {
+    [key: string]: Tool | (() => RpcToolset);
+} | Tool[];
+export declare function generateToolTypes(tools: WrappableTools, name: string): AsyncGenerator<string, void, unknown>;
+export declare const generateToolApi: (tools: WrappableTools, opts: ToolExecutionOptions) => {
+    new (code: string): {
+        __return_value__: unknown;
+        __raw_code__: string;
+        __code__(): Promise<string>;
+        __return__(result: unknown): void;
+        __RPC_TARGET_BRAND: never;
+    };
+};
+export type ToolApi = InstanceType<ReturnType<typeof generateToolApi>>;

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "exoagent",
   "type": "module",
-  "version": "0.0.1",
-  "description": " The OS kernel to safely unleash your agents",
+  "version": "0.0.2",
+  "description": "The OS kernel to safely unleash your agents",
   "author": "Ryan Rasti <https://github.com/ryanrasti>",
   "license": "MIT",
   "homepage": "https://github.com/ryanrasti/exoagent#readme",
@@ -20,37 +20,49 @@
   ],
   "sideEffects": false,
   "exports": {
-    ".": "./dist/index.mjs",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./sql": {
+      "types": "./dist/sql.d.ts",
+      "import": "./dist/sql.mjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.mjs",
   "module": "./dist/index.mjs",
-  "types": "./dist/index.d.mts",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist"
   ],
   "scripts": {
     "clean": "rm -rf dist",
-    "build": "npm run clean && npm run build:dts && npm run build:main && npm run build:runtime-bundle && npm run build:test-deps",
-    "build:main": "esbuild src/index.ts --bundle --format=esm --target=es2022 --outfile=dist/index.mjs --packages=external",
-    "build:dts": "tsdown --dts-only",
-    "build:runtime-bundle": "esbuild src/code-mode-runtime.ts --bundle --format=esm --target=es2022 --outfile=dist/code-mode-runtime.mjs --packages=external",
-    "build:test-deps": "npm run build:runtime-bundle && tsdown --config tsdown.test-deps.config.ts",
+    "build": "npm run clean && npm run build:runtime && npm run build:main && npm run build:capnweb && npm run build:test-deps",
+    "build:main": "vite build",
+    "build:runtime": "esbuild src/code-mode-runtime.ts --bundle --format=esm --target=es2022 --outfile=dist/code-mode-runtime.mjs --packages=external",
+    "build:capnweb": "npm pack ./packages/capnweb --pack-destination dist && mkdir -p dist/capnweb && tar -xzf dist/capnweb-*.tgz --strip-components=2 -C dist/capnweb package/dist && rm dist/capnweb-*.tgz",
+    "build:test-deps": "tsdown --config tsdown.test-deps.config.ts",
     "dev": "tsdown --watch",
     "lint": "eslint",
     "prepublishOnly": "npm run build",
     "release": "bumpp",
     "start": "tsx src/index.ts",
+    "pretest": "npm run build:runtime",
     "test": "vitest --run",
     "typecheck": "tsc",
     "ci:capnweb": "cd packages/capnweb && npm ci && npm run build",
-    "ci": "npm run ci:capnweb && npm ci && npm run lint && npm run typecheck && npm run build && npm run test"
+    "ci:examples": "npm --prefix ./examples run ci",
+    "ci": "npm run ci:capnweb && npm ci && npm run lint && npm run typecheck && npm run build && npm run test && npm run ci:examples"
+  },
+  "peerDependencies": {
+    "ai": "^6.0.0"
   },
   "dependencies": {
-    "ai": "^6.0.3",
     "camelcase": "^9.0.0",
+    "capnweb": "file:packages/capnweb",
     "json-schema": "^0.4.0",
-    "json-schema-to-typescript": "^15.0.4",
+    "json-schema-to-typescript": "^15.0.0",
     "kysely": "^0.28.9",
     "tiny-invariant": "^1.3.3",
     "zod": "^4.2.1",
@@ -74,6 +86,8 @@
     "tsx": "4.21.0",
     "typescript": "5.9.3",
     "vite": "7.2.7",
+    "vite-plugin-dts": "^4.5.4",
+    "vite-plugin-externalize-deps": "^0.10.0",
     "vitest": "4.0.15",
     "vitest-package-exports": "0.1.1",
     "yaml": "2.8.2"