exoagent 0.0.1

package/dist/nodefs-C8H-6XZ_.mjs

@@ -0,0 +1,26 @@
+import { h as u, s as ur, t as C } from "./chunk-VBDAOXYI-BhoIkhUn.mjs";
+import * as s from "fs";
+import * as o from "path";
+
+//#region node_modules/@electric-sql/pglite/dist/fs/nodefs.js
+u();
+var m = class extends ur {
+	constructor(t) {
+		super(t), this.rootDir = o.resolve(t), s.existsSync(o.join(this.rootDir)) || s.mkdirSync(this.rootDir);
+	}
+	async init(t, e) {
+		return this.pg = t, { emscriptenOpts: {
+			...e,
+			preRun: [...e.preRun || [], (r) => {
+				let c = r.FS.filesystems.NODEFS;
+				r.FS.mkdir(C), r.FS.mount(c, { root: this.rootDir }, C);
+			}]
+		} };
+	}
+	async closeFs() {
+		this.pg.Module.FS.quit();
+	}
+};
+
+//#endregion
+export { m as NodeFS };

package/dist/opfs-ahp-Dy9HQOrY.mjs

@@ -0,0 +1,367 @@
+import { d as R, f as T, g as x, h as u, i as cr, m as h, o as pr, p as U } from "./chunk-VBDAOXYI-BhoIkhUn.mjs";
+
+//#region node_modules/@electric-sql/pglite/dist/fs/opfs-ahp.js
+u();
+var $ = "state.txt", G = "data", T$1 = {
+	DIR: 16384,
+	FILE: 32768
+}, H, v, F, M, y, b, m, x$1, P, D, S, n, C, O, k, w, f, I, W, j, L = class extends cr {
+	constructor(e, { initialPoolSize: t = 1e3, maintainedPoolSize: o = 100, debug: i = !1 } = {}) {
+		super(e, { debug: i });
+		R(this, n);
+		R(this, H);
+		R(this, v);
+		R(this, F);
+		R(this, M);
+		R(this, y);
+		R(this, b, /* @__PURE__ */ new Map());
+		R(this, m, /* @__PURE__ */ new Map());
+		R(this, x$1, 0);
+		R(this, P, /* @__PURE__ */ new Map());
+		R(this, D, /* @__PURE__ */ new Map());
+		this.lastCheckpoint = 0;
+		this.checkpointInterval = 1e3 * 60;
+		this.poolCounter = 0;
+		R(this, S, /* @__PURE__ */ new Set());
+		this.initialPoolSize = t, this.maintainedPoolSize = o;
+	}
+	async init(e, t) {
+		return await T(this, n, C).call(this), super.init(e, t);
+	}
+	async syncToFs(e = !1) {
+		await this.maybeCheckpointState(), await this.maintainPool(), e || this.flush();
+	}
+	async closeFs() {
+		for (let e of h(this, m).values()) e.close();
+		h(this, y).flush(), h(this, y).close(), this.pg.Module.FS.quit();
+	}
+	async maintainPool(e) {
+		e = e || this.maintainedPoolSize;
+		let t = e - this.state.pool.length, o = [];
+		for (let i = 0; i < t; i++) o.push(new Promise(async (c) => {
+			++this.poolCounter;
+			let a = `${(Date.now() - 1704063600).toString(16).padStart(8, "0")}-${this.poolCounter.toString(16).padStart(8, "0")}`, h$1 = await h(this, F).getFileHandle(a, { create: !0 }), d = await h$1.createSyncAccessHandle();
+			h(this, b).set(a, h$1), h(this, m).set(a, d), T(this, n, k).call(this, {
+				opp: "createPoolFile",
+				args: [a]
+			}), this.state.pool.push(a), c();
+		}));
+		for (let i = 0; i > t; i--) o.push(new Promise(async (c) => {
+			let a = this.state.pool.pop();
+			T(this, n, k).call(this, {
+				opp: "deletePoolFile",
+				args: [a]
+			});
+			let h$1 = h(this, b).get(a);
+			h(this, m).get(a)?.close(), await h(this, F).removeEntry(h$1.name), h(this, b).delete(a), h(this, m).delete(a), c();
+		}));
+		await Promise.all(o);
+	}
+	_createPoolFileState(e) {
+		this.state.pool.push(e);
+	}
+	_deletePoolFileState(e) {
+		let t = this.state.pool.indexOf(e);
+		t > -1 && this.state.pool.splice(t, 1);
+	}
+	async maybeCheckpointState() {
+		Date.now() - this.lastCheckpoint > this.checkpointInterval && await this.checkpointState();
+	}
+	async checkpointState() {
+		let e = new TextEncoder().encode(JSON.stringify(this.state));
+		h(this, y).truncate(0), h(this, y).write(e, { at: 0 }), h(this, y).flush(), this.lastCheckpoint = Date.now();
+	}
+	flush() {
+		for (let e of h(this, S)) try {
+			e.flush();
+		} catch {}
+		h(this, S).clear();
+	}
+	chmod(e, t) {
+		T(this, n, O).call(this, {
+			opp: "chmod",
+			args: [e, t]
+		}, () => {
+			this._chmodState(e, t);
+		});
+	}
+	_chmodState(e, t) {
+		let o = T(this, n, f).call(this, e);
+		o.mode = t;
+	}
+	close(e) {
+		let t = T(this, n, I).call(this, e);
+		h(this, P).delete(e), h(this, D).delete(t);
+	}
+	fstat(e) {
+		let t = T(this, n, I).call(this, e);
+		return this.lstat(t);
+	}
+	lstat(e) {
+		let t = T(this, n, f).call(this, e), o = t.type === "file" ? h(this, m).get(t.backingFilename).getSize() : 0, i = 4096;
+		return {
+			dev: 0,
+			ino: 0,
+			mode: t.mode,
+			nlink: 1,
+			uid: 0,
+			gid: 0,
+			rdev: 0,
+			size: o,
+			blksize: i,
+			blocks: Math.ceil(o / i),
+			atime: t.lastModified,
+			mtime: t.lastModified,
+			ctime: t.lastModified
+		};
+	}
+	mkdir(e, t) {
+		T(this, n, O).call(this, {
+			opp: "mkdir",
+			args: [e, t]
+		}, () => {
+			this._mkdirState(e, t);
+		});
+	}
+	_mkdirState(e, t) {
+		let o = T(this, n, w).call(this, e), i = o.pop(), c = [], a = this.state.root;
+		for (let d of o) {
+			if (c.push(e), !Object.prototype.hasOwnProperty.call(a.children, d)) if (t?.recursive) this.mkdir(c.join("/"));
+			else throw new p("ENOENT", "No such file or directory");
+			if (a.children[d].type !== "directory") throw new p("ENOTDIR", "Not a directory");
+			a = a.children[d];
+		}
+		if (Object.prototype.hasOwnProperty.call(a.children, i)) throw new p("EEXIST", "File exists");
+		let h$1 = {
+			type: "directory",
+			lastModified: Date.now(),
+			mode: t?.mode || T$1.DIR,
+			children: {}
+		};
+		a.children[i] = h$1;
+	}
+	open(e, t, o) {
+		if (T(this, n, f).call(this, e).type !== "file") throw new p("EISDIR", "Is a directory");
+		let c = T(this, n, W).call(this);
+		return h(this, P).set(c, e), h(this, D).set(e, c), c;
+	}
+	readdir(e) {
+		let t = T(this, n, f).call(this, e);
+		if (t.type !== "directory") throw new p("ENOTDIR", "Not a directory");
+		return Object.keys(t.children);
+	}
+	read(e, t, o, i, c) {
+		let a = T(this, n, I).call(this, e), h$1 = T(this, n, f).call(this, a);
+		if (h$1.type !== "file") throw new p("EISDIR", "Is a directory");
+		return h(this, m).get(h$1.backingFilename).read(new Uint8Array(t.buffer, o, i), { at: c });
+	}
+	rename(e, t) {
+		T(this, n, O).call(this, {
+			opp: "rename",
+			args: [e, t]
+		}, () => {
+			this._renameState(e, t, !0);
+		});
+	}
+	_renameState(e, t, o = !1) {
+		let i = T(this, n, w).call(this, e), c = i.pop(), a = T(this, n, f).call(this, i.join("/"));
+		if (!Object.prototype.hasOwnProperty.call(a.children, c)) throw new p("ENOENT", "No such file or directory");
+		let h$1 = T(this, n, w).call(this, t), d = h$1.pop(), l = T(this, n, f).call(this, h$1.join("/"));
+		if (o && Object.prototype.hasOwnProperty.call(l.children, d)) {
+			let u$1 = l.children[d];
+			h(this, m).get(u$1.backingFilename).truncate(0), this.state.pool.push(u$1.backingFilename);
+		}
+		l.children[d] = a.children[c], delete a.children[c];
+	}
+	rmdir(e) {
+		T(this, n, O).call(this, {
+			opp: "rmdir",
+			args: [e]
+		}, () => {
+			this._rmdirState(e);
+		});
+	}
+	_rmdirState(e) {
+		let t = T(this, n, w).call(this, e), o = t.pop(), i = T(this, n, f).call(this, t.join("/"));
+		if (!Object.prototype.hasOwnProperty.call(i.children, o)) throw new p("ENOENT", "No such file or directory");
+		let c = i.children[o];
+		if (c.type !== "directory") throw new p("ENOTDIR", "Not a directory");
+		if (Object.keys(c.children).length > 0) throw new p("ENOTEMPTY", "Directory not empty");
+		delete i.children[o];
+	}
+	truncate(e, t = 0) {
+		let o = T(this, n, f).call(this, e);
+		if (o.type !== "file") throw new p("EISDIR", "Is a directory");
+		let i = h(this, m).get(o.backingFilename);
+		if (!i) throw new p("ENOENT", "No such file or directory");
+		i.truncate(t), h(this, S).add(i);
+	}
+	unlink(e) {
+		T(this, n, O).call(this, {
+			opp: "unlink",
+			args: [e]
+		}, () => {
+			this._unlinkState(e, !0);
+		});
+	}
+	_unlinkState(e, t = !1) {
+		let o = T(this, n, w).call(this, e), i = o.pop(), c = T(this, n, f).call(this, o.join("/"));
+		if (!Object.prototype.hasOwnProperty.call(c.children, i)) throw new p("ENOENT", "No such file or directory");
+		let a = c.children[i];
+		if (a.type !== "file") throw new p("EISDIR", "Is a directory");
+		if (delete c.children[i], t) {
+			let h$1 = h(this, m).get(a.backingFilename);
+			h$1?.truncate(0), h(this, S).add(h$1), h(this, D).has(e) && (h(this, P).delete(h(this, D).get(e)), h(this, D).delete(e));
+		}
+		this.state.pool.push(a.backingFilename);
+	}
+	utimes(e, t, o) {
+		T(this, n, O).call(this, {
+			opp: "utimes",
+			args: [
+				e,
+				t,
+				o
+			]
+		}, () => {
+			this._utimesState(e, t, o);
+		});
+	}
+	_utimesState(e, t, o) {
+		let i = T(this, n, f).call(this, e);
+		i.lastModified = o;
+	}
+	writeFile(e, t, o) {
+		let i = T(this, n, w).call(this, e), c = i.pop(), a = T(this, n, f).call(this, i.join("/"));
+		if (Object.prototype.hasOwnProperty.call(a.children, c)) {
+			let l = a.children[c];
+			l.lastModified = Date.now(), T(this, n, k).call(this, {
+				opp: "setLastModified",
+				args: [e, l.lastModified]
+			});
+		} else {
+			if (this.state.pool.length === 0) throw new Error("No more file handles available in the pool");
+			let l = {
+				type: "file",
+				lastModified: Date.now(),
+				mode: o?.mode || T$1.FILE,
+				backingFilename: this.state.pool.pop()
+			};
+			a.children[c] = l, T(this, n, k).call(this, {
+				opp: "createFileNode",
+				args: [e, l]
+			});
+		}
+		let h$1 = a.children[c], d = h(this, m).get(h$1.backingFilename);
+		t.length > 0 && (d.write(typeof t == "string" ? new TextEncoder().encode(t) : new Uint8Array(t), { at: 0 }), e.startsWith("/pg_wal") && h(this, S).add(d));
+	}
+	_createFileNodeState(e, t) {
+		let o = T(this, n, w).call(this, e), i = o.pop(), c = T(this, n, f).call(this, o.join("/"));
+		c.children[i] = t;
+		let a = this.state.pool.indexOf(t.backingFilename);
+		return a > -1 && this.state.pool.splice(a, 1), t;
+	}
+	_setLastModifiedState(e, t) {
+		let o = T(this, n, f).call(this, e);
+		o.lastModified = t;
+	}
+	write(e, t, o, i, c) {
+		let a = T(this, n, I).call(this, e), h$1 = T(this, n, f).call(this, a);
+		if (h$1.type !== "file") throw new p("EISDIR", "Is a directory");
+		let d = h(this, m).get(h$1.backingFilename);
+		if (!d) throw new p("EBADF", "Bad file descriptor");
+		let l = d.write(new Uint8Array(t, o, i), { at: c });
+		return a.startsWith("/pg_wal") && h(this, S).add(d), l;
+	}
+};
+H = /* @__PURE__ */ new WeakMap(), v = /* @__PURE__ */ new WeakMap(), F = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), y = /* @__PURE__ */ new WeakMap(), b = /* @__PURE__ */ new WeakMap(), m = /* @__PURE__ */ new WeakMap(), x$1 = /* @__PURE__ */ new WeakMap(), P = /* @__PURE__ */ new WeakMap(), D = /* @__PURE__ */ new WeakMap(), S = /* @__PURE__ */ new WeakMap(), n = /* @__PURE__ */ new WeakSet(), C = async function() {
+	x(this, H, await navigator.storage.getDirectory()), x(this, v, await T(this, n, j).call(this, this.dataDir, { create: !0 })), x(this, F, await T(this, n, j).call(this, G, {
+		from: h(this, v),
+		create: !0
+	})), x(this, M, await h(this, v).getFileHandle($, { create: !0 })), x(this, y, await h(this, M).createSyncAccessHandle());
+	let e = new ArrayBuffer(h(this, y).getSize());
+	h(this, y).read(e, { at: 0 });
+	let t, o = new TextDecoder().decode(e).split(`
+`), i = !1;
+	try {
+		t = JSON.parse(o[0]);
+	} catch {
+		t = {
+			root: {
+				type: "directory",
+				lastModified: Date.now(),
+				mode: T$1.DIR,
+				children: {}
+			},
+			pool: []
+		}, h(this, y).truncate(0), h(this, y).write(new TextEncoder().encode(JSON.stringify(t)), { at: 0 }), i = !0;
+	}
+	this.state = t;
+	let c = o.slice(1).filter(Boolean).map((l) => JSON.parse(l));
+	for (let l of c) {
+		let u$1 = `_${l.opp}State`;
+		if (typeof this[u$1] == "function") try {
+			this[u$1].bind(this)(...l.args);
+		} catch (N) {
+			console.warn("Error applying OPFS AHP WAL entry", l, N);
+		}
+	}
+	let a = [], h$1 = async (l) => {
+		if (l.type === "file") try {
+			let u$1 = await h(this, F).getFileHandle(l.backingFilename), N = await u$1.createSyncAccessHandle();
+			h(this, b).set(l.backingFilename, u$1), h(this, m).set(l.backingFilename, N);
+		} catch (u$1) {
+			console.error("Error opening file handle for node", l, u$1);
+		}
+		else for (let u$1 of Object.values(l.children)) a.push(h$1(u$1));
+	};
+	await h$1(this.state.root);
+	let d = [];
+	for (let l of this.state.pool) d.push(new Promise(async (u$1) => {
+		h(this, b).has(l) && console.warn("File handle already exists for pool file", l);
+		let N = await h(this, F).getFileHandle(l), U$1 = await N.createSyncAccessHandle();
+		h(this, b).set(l, N), h(this, m).set(l, U$1), u$1();
+	}));
+	await Promise.all([...a, ...d]), await this.maintainPool(i ? this.initialPoolSize : this.maintainedPoolSize);
+}, O = function(e, t) {
+	let o = T(this, n, k).call(this, e);
+	try {
+		t();
+	} catch (i) {
+		throw h(this, y).truncate(o), i;
+	}
+}, k = function(e) {
+	let t = JSON.stringify(e), o = new TextEncoder().encode(`
+${t}`), i = h(this, y).getSize();
+	return h(this, y).write(o, { at: i }), h(this, S).add(h(this, y)), i;
+}, w = function(e) {
+	return e.split("/").filter(Boolean);
+}, f = function(e, t) {
+	let o = T(this, n, w).call(this, e), i = t || this.state.root;
+	for (let c of o) {
+		if (i.type !== "directory") throw new p("ENOTDIR", "Not a directory");
+		if (!Object.prototype.hasOwnProperty.call(i.children, c)) throw new p("ENOENT", "No such file or directory");
+		i = i.children[c];
+	}
+	return i;
+}, I = function(e) {
+	let t = h(this, P).get(e);
+	if (!t) throw new p("EBADF", "Bad file descriptor");
+	return t;
+}, W = function() {
+	let e = ++U(this, x$1)._;
+	for (; h(this, P).has(e);) U(this, x$1)._++;
+	return e;
+}, j = async function(e, t) {
+	let o = T(this, n, w).call(this, e), i = t?.from || h(this, H);
+	for (let c of o) i = await i.getDirectoryHandle(c, { create: t?.create });
+	return i;
+};
+var p = class extends Error {
+	constructor(A, e) {
+		super(e), typeof A == "number" ? this.code = A : typeof A == "string" && (this.code = pr[A]);
+	}
+};
+
+//#endregion
+export { L as OpfsAhpFS };

package/dist/rpc-toolset-test-helpers.d.mts

@@ -0,0 +1,245 @@
+import * as kysely0 from "kysely";
+import { CompiledQuery, Dialect, RawBuilder } from "kysely";
+
+//#region packages/capnweb/dist/index.d.ts
+
+declare const __RPC_TARGET_BRAND: '__RPC_TARGET_BRAND';
+interface RpcTargetBranded {
+  [__RPC_TARGET_BRAND]: never;
+}
+
+// Types that can be used through `Stub`s
+
+/**
+ * Classes which are intended to be passed by reference and called over RPC must extend
+ * `RpcTarget`. A class which does not extend `RpcTarget` (and which doesn't have built-in support
+ * from the RPC system) cannot be passed in an RPC message at all; an exception will be thrown.
+ *
+ * Note that on Cloudflare Workers, this `RpcTarget` is an alias for the one exported from the
+ * "cloudflare:workers" module, so they can be used interchangably.
+ */
+interface RpcTarget extends RpcTargetBranded {}
+declare const RpcTarget: {
+  new (): RpcTarget;
+};
+/**
+ * Empty interface used as default type parameter for sessions where the other side doesn't
+ * necessarily export a main interface.
+ */
+//#endregion
+//#region src/rpc-toolset.d.ts
+
+declare const callbackMetadataKey: unique symbol;
+type ToolCallback<T extends (arg: any) => unknown> = T | {
+  [callbackMetadataKey]: {
+    callback: T;
+  };
+};
+declare class RpcToolset extends RpcTarget {
+  constructor();
+}
+//#endregion
+//#region src/sql/sql.d.ts
+type RawSql = RawBuilder<unknown>;
+//#endregion
+//#region src/sql/expression.d.ts
+type LiteralValue = number | string | boolean | null;
+type SqlExpressionIn = LiteralValue | SqlExpression;
+declare class SqlExpression extends RpcToolset {
+  precedence: number;
+  constructor(precedence?: number);
+  compile: () => RawSql;
+  or(expr: SqlExpression): BinaryExpression;
+  and(expr: SqlExpression): BinaryExpression;
+  not(): UnaryExpression;
+  isNull(): UnaryExpression;
+  isNotNull(): UnaryExpression;
+  '<'(expr: SqlExpression | number | string): BinaryExpression;
+  '<='(expr: SqlExpression | number | string): BinaryExpression;
+  '>'(expr: SqlExpression | number | string): BinaryExpression;
+  '>='(expr: SqlExpression | number | string): BinaryExpression;
+  '='(expr: SqlExpressionIn): BinaryExpression;
+  '<>'(expr: SqlExpressionIn): BinaryExpression;
+  '!='(expr: SqlExpressionIn): BinaryExpression;
+  'LIKE'(expr: SqlExpression | string): BinaryExpression;
+  'NOT LIKE'(expr: SqlExpression | string): BinaryExpression;
+  '+'(expr: SqlExpression | number | string): BinaryExpression;
+  '-'(expr: SqlExpression | number | string): BinaryExpression;
+  '*'(expr: SqlExpression | number | string): BinaryExpression;
+  '/'(expr: SqlExpression | number | string): BinaryExpression;
+  '%'(expr: SqlExpression | number | string): BinaryExpression;
+  asc(): OrderByValue;
+  desc(): OrderByValue;
+}
+declare class BinaryExpression extends SqlExpression {
+  private readonly left;
+  private readonly right;
+  private readonly operator;
+  constructor(left: SqlExpression, right: SqlExpression, operator: RawSql, precedence?: number);
+  compile: () => kysely0.RawBuilder<unknown>;
+}
+declare class UnaryExpression extends SqlExpression {
+  private readonly operand;
+  private readonly operator;
+  private readonly placement;
+  constructor(operand: SqlExpression, operator: RawSql, placement: 'prefix' | 'postfix', precedence?: number);
+  compile: () => kysely0.RawBuilder<unknown>;
+}
+declare class ColumnReferenceExpression extends SqlExpression {
+  readonly alias: string;
+  readonly column: string;
+  constructor(alias: string, column: string);
+  compile: () => kysely0.RawBuilder<unknown>;
+}
+declare class OrderByValue {
+  value: SqlExpression;
+  direction?: RawSql | undefined;
+  constructor(value: SqlExpression, direction?: RawSql | undefined);
+}
+//#endregion
+//#region src/sql/builder.d.ts
+type RowLikeRaw = {
+  [key: string]: SqlExpression;
+};
+type RowLikeRawIn = {
+  [key: string]: SqlExpressionIn;
+};
+type RowLike = RowLikeRaw | TableBase;
+type RowLikeIn = RowLikeRawIn | RowLike;
+type AsRowLike<R$1 extends RowLikeIn> = R$1 extends TableBase ? R$1 : { [key in keyof R$1]: R$1[key] extends SqlExpression ? R$1[key] : SqlExpression };
+type NamespacedExpression<A, R$1> = (arg: A) => R$1;
+type FromItem<N extends string, F extends RowLike> = {
+  alias: N;
+  toRowLike: () => F;
+  compile: (opts?: {
+    isSubquery?: boolean;
+  }) => RawSql;
+  onExpression?: SqlExpression;
+};
+type TableNamespace = {
+  [key: string]: RowLike;
+};
+type OrderByItem<TN extends TableNamespace> = NamespacedExpression<TN, SqlExpression | SqlExpression[] | OrderByValue | OrderByValue[] | (SqlExpression | OrderByValue)[]>;
+type Tables<TN extends TableNamespace> = { [k in keyof TN & string]: {
+  fromItem: FromItem<k, TN[k]>;
+  joinType: 'inner' | 'left' | null;
+  on?: SqlExpression;
+  isLateral: boolean;
+} };
+type QueryBuilderParams<N extends string, TN extends TableNamespace, S extends RowLike> = {
+  db: Database;
+  alias: N;
+  tables: Tables<TN>;
+  selectRowLike: S;
+  whereExpression?: SqlExpression;
+  orderByExpressions?: OrderByValue[];
+  limit?: number;
+  offset?: number;
+  rawTable: TableClass<N> | undefined;
+};
+declare class QueryBuilder<N extends string, TN extends TableNamespace, S extends RowLike> extends RpcToolset implements FromItem<N, S> {
+  #private;
+  readonly alias: N;
+  private selectRowLike;
+  private tables;
+  private whereExpression?;
+  private orderByExpressions?;
+  private arg;
+  private rawTable;
+  constructor(params: QueryBuilderParams<N, TN, S>);
+  select<S2 extends RowLikeIn>(select: ToolCallback<(arg: TN) => S2>): QueryBuilder<N, TN, AsRowLike<S2>>;
+  where(where: ToolCallback<(arg: TN) => SqlExpressionIn>): QueryBuilder<N, TN, S>;
+  orderBy(orderBy: ToolCallback<OrderByItem<TN>>): QueryBuilder<N, TN, S>;
+  limit(limit: number): QueryBuilder<N, TN, S>;
+  offset(offset: number): QueryBuilder<N, TN, S>;
+  join<N2 extends string, F2 extends TableClass<N2>>(fromItem: F2 | NamespacedExpression<TN, F2>, on?: NamespacedExpression<TN & { [k in N2]: InstanceType<F2> }, SqlExpressionIn>): QueryBuilder<N, TN & { [k in N2]: InstanceType<F2> }, S>;
+  join<N2 extends string, F2 extends RowLike>(fromItem: FromItem<N2, F2> | NamespacedExpression<TN, FromItem<N2, F2>>, on?: NamespacedExpression<TN & { [k in N2]: F2 }, SqlExpressionIn>): QueryBuilder<N, TN & { [k in N2]: F2 }, S>;
+  execute(): Promise<{ [key in keyof S]: unknown }[]>;
+  private paramsForCopy;
+  toRowLike: () => S;
+  compile: (opts?: {
+    isSubquery?: boolean;
+  }) => kysely0.RawBuilder<unknown>;
+}
+declare class TableBase extends RpcToolset {
+  opts?: {
+    remapColumns?: boolean;
+  };
+  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
+}
+type TableClass<N extends string = string> = {
+  new (opts?: {
+    remapColumns?: boolean;
+  }): TableBase;
+  as: <T extends TableClass, N2 extends string>(this: T, alias: N2) => Omit<T, keyof TableClass> & TableClass<N2> & {
+    new (): InstanceType<T>;
+  };
+  toRowLike: <T extends TableClass>(this: T, opts?: {
+    remapColumns?: boolean;
+  }) => InstanceType<T>;
+  from: <T extends TableClass>(this: T) => QueryBuilder<N, { [k in N]: InstanceType<T> }, InstanceType<T>>;
+  on: <T extends TableClass>(this: T, on: NamespacedExpression<InstanceType<T>, SqlExpression>) => T;
+  compile: () => RawSql;
+  alias: N;
+  tableName: string;
+  onExpression?: SqlExpression;
+};
+declare class Database {
+  private dialect;
+  private opts?;
+  private kysely?;
+  constructor(dialect: Dialect, opts?: {
+    logQuery?: (raw: CompiledQuery) => void;
+  } | undefined);
+  execute(query: RawSql): Promise<unknown[]>;
+  Table<N extends string>(name: N): TableClass<N>;
+}
+//#endregion
+//#region src/rpc-toolset-test-helpers.d.ts
+declare class TestToolset extends RpcToolset {
+  add(input: {
+    a: number;
+    b: number;
+  }): Promise<number>;
+  toolset2(): Promise<TestToolset2>;
+  userForId({
+    id
+  }: {
+    id: string;
+  }): Promise<typeof User>;
+}
+declare class TestToolset2 extends RpcToolset {
+  subtract(input: {
+    a: number;
+    b: number;
+  }): Promise<number>;
+}
+declare const User_base: Omit<TableClass<"users">, keyof TableClass<string>> & TableClass<"user"> & (new () => {
+  opts?: {
+    remapColumns?: boolean;
+  };
+  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
+  __RPC_TARGET_BRAND: never;
+});
+declare class User extends User_base {
+  id: ColumnReferenceExpression;
+  name: ColumnReferenceExpression;
+  email: ColumnReferenceExpression;
+  age: ColumnReferenceExpression;
+  posts(): typeof Post;
+}
+declare const Post_base: Omit<TableClass<"posts">, keyof TableClass<string>> & TableClass<"post"> & (new () => {
+  opts?: {
+    remapColumns?: boolean;
+  };
+  column: (this: InstanceType<TableClass<string>>, columnName: string) => ColumnReferenceExpression;
+  __RPC_TARGET_BRAND: never;
+});
+declare class Post extends Post_base {
+  id: ColumnReferenceExpression;
+  userId: ColumnReferenceExpression;
+  title: ColumnReferenceExpression;
+  content: ColumnReferenceExpression;
+}
+//#endregion
+export { Post, TestToolset, TestToolset2, User };