diff --git a/crates/bindings-typescript/src/index.ts b/crates/bindings-typescript/src/index.ts
index b21040d450a..7061d1448ce 100644
--- a/crates/bindings-typescript/src/index.ts
+++ b/crates/bindings-typescript/src/index.ts
@@ -11,4 +11,5 @@ export * from './lib/util';
 export * from './lib/identity';
 export * from './lib/option';
 export * from './lib/result';
+export * from './lib/query';
 export * from './sdk';
diff --git a/crates/bindings-typescript/src/lib/query.ts b/crates/bindings-typescript/src/lib/query.ts
new file mode 100644
index 00000000000..fa9c543b057
--- /dev/null
+++ b/crates/bindings-typescript/src/lib/query.ts
@@ -0,0 +1,778 @@
+import { ConnectionId } from './connection_id';
+import { Identity } from './identity';
+import type { ColumnIndex, IndexColumns, IndexOpts } from './indexes';
+import type { UntypedSchemaDef } from './schema';
+import type { TableSchema } from './table_schema';
+import type {
+  ColumnBuilder,
+  ColumnMetadata,
+  RowBuilder,
+  TypeBuilder,
+} from './type_builders';
+
+/**
+ * Helper to get the set of table names.
+ */
+export type TableNames<SchemaDef extends UntypedSchemaDef> =
+  SchemaDef['tables'][number]['name'] & string;
+
+/** helper: pick the table def object from the schema by its name */
+export type TableDefByName<
+  SchemaDef extends UntypedSchemaDef,
+  Name extends TableNames<SchemaDef>,
+> = Extract<SchemaDef['tables'][number], { name: Name }>;
+
+// internal only — NOT exported.
+// This is how we make sure queries are only created with our helpers.
+const QueryBrand = Symbol('QueryBrand');
+
+export interface TableTypedQuery<TableDef extends TypedTableDef> {
+  readonly [QueryBrand]: true;
+  readonly __table?: TableDef;
+}
+
+export interface RowTypedQuery<Row, ST> {
+  readonly [QueryBrand]: true;
+  // Phantom type to track the row type.
+  readonly __row?: Row;
+  readonly __algebraicType?: ST;
+}
+
+export type Query<TableDef extends TypedTableDef> = RowTypedQuery<
+  RowType<TableDef>,
+  TableDef['rowType']
+>;
+
+export const isRowTypedQuery = (val: unknown): val is RowTypedQuery<any, any> =>
+  !!val && typeof val === 'object' && QueryBrand in (val as object);
+
+export const isTypedQuery = (val: unknown): val is TableTypedQuery<any> =>
+  !!val && typeof val === 'object' && QueryBrand in (val as object);
+
+export function toSql(q: Query<any>): string {
+  return (q as unknown as { toSql(): string }).toSql();
+}
+
+// A query builder with a single table.
+type From<TableDef extends TypedTableDef> = Readonly<{
+  where(
+    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+  ): From<TableDef>;
+  rightSemijoin<RightTable extends TypedTableDef>(
+    other: TableRef<RightTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<RightTable>
+    ) => EqExpr<TableDef | RightTable>
+  ): SemijoinBuilder<RightTable>;
+  leftSemijoin<RightTable extends TypedTableDef>(
+    other: TableRef<RightTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<RightTable>
+    ) => EqExpr<TableDef | RightTable>
+  ): SemijoinBuilder<TableDef>;
+  build(): Query<TableDef>;
+}>;
+
+// A query builder with a semijoin.
+type SemijoinBuilder<TableDef extends TypedTableDef> = Readonly<{
+  where(
+    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+  ): SemijoinBuilder<TableDef>;
+  build(): Query<TableDef>;
+}>;
+
+class SemijoinImpl<TableDef extends TypedTableDef>
+  implements SemijoinBuilder<TableDef>, TableTypedQuery<TableDef>
+{
+  readonly [QueryBrand] = true;
+  readonly type = 'semijoin' as const;
+  constructor(
+    readonly sourceQuery: FromBuilder<TableDef>,
+    readonly filterQuery: FromBuilder<any>,
+    readonly joinCondition: EqExpr<any>
+  ) {
+    if (sourceQuery.table.name === filterQuery.table.name) {
+      // TODO: Handle aliasing properly instead of just forbidding it.
+      throw new Error('Cannot semijoin a table to itself');
+    }
+  }
+
+  build(): Query<TableDef> {
+    return this as Query<TableDef>;
+  }
+
+  where(
+    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+  ): SemijoinImpl<TableDef> {
+    const nextSourceQuery = this.sourceQuery.where(predicate);
+    return new SemijoinImpl<TableDef>(
+      nextSourceQuery,
+      this.filterQuery,
+      this.joinCondition
+    );
+  }
+
+  toSql(): string {
+    const left = this.filterQuery;
+    const right = this.sourceQuery;
+    const leftTable = quoteIdentifier(left.table.name);
+    const rightTable = quoteIdentifier(right.table.name);
+    let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`;
+
+    const clauses: string[] = [];
+    if (left.whereClause) {
+      clauses.push(booleanExprToSql(left.whereClause));
+    }
+    if (right.whereClause) {
+      clauses.push(booleanExprToSql(right.whereClause));
+    }
+
+    if (clauses.length > 0) {
+      const whereSql =
+        clauses.length === 1
+          ? clauses[0]
+          : clauses.map(wrapInParens).join(' AND ');
+      sql += ` WHERE ${whereSql}`;
+    }
+
+    return sql;
+  }
+}
+
+class FromBuilder<TableDef extends TypedTableDef>
+  implements From<TableDef>, TableTypedQuery<TableDef>
+{
+  readonly [QueryBrand] = true;
+  constructor(
+    readonly table: TableRef<TableDef>,
+    readonly whereClause?: BooleanExpr<TableDef>
+  ) {}
+
+  where(
+    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+  ): FromBuilder<TableDef> {
+    const newCondition = predicate(this.table.cols);
+    const nextWhere = this.whereClause
+      ? and(this.whereClause, newCondition)
+      : newCondition;
+    return new FromBuilder<TableDef>(this.table, nextWhere);
+  }
+
+  rightSemijoin<OtherTable extends TypedTableDef>(
+    right: TableRef<OtherTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<OtherTable>
+    ) => EqExpr<TableDef | OtherTable>
+  ): SemijoinBuilder<OtherTable> {
+    const sourceQuery = new FromBuilder(right);
+    const joinCondition = on(
+      this.table.indexedCols,
+      right.indexedCols
+    ) as EqExpr<any>;
+    return new SemijoinImpl<OtherTable>(sourceQuery, this, joinCondition);
+  }
+
+  leftSemijoin<OtherTable extends TypedTableDef>(
+    right: TableRef<OtherTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<OtherTable>
+    ) => EqExpr<TableDef | OtherTable>
+  ): SemijoinBuilder<TableDef> {
+    const filterQuery = new FromBuilder(right);
+    const joinCondition = on(
+      this.table.indexedCols,
+      right.indexedCols
+    ) as EqExpr<any>;
+    return new SemijoinImpl<TableDef>(this, filterQuery, joinCondition);
+  }
+
+  toSql(): string {
+    return renderSelectSqlWithJoins(this.table, this.whereClause);
+  }
+
+  build(): Query<TableDef> {
+    return this as Query<TableDef>;
+  }
+}
+
+export type QueryBuilder<SchemaDef extends UntypedSchemaDef> = {
+  readonly [Tbl in SchemaDef['tables'][number] as Tbl['name']]: TableRef<Tbl> &
+    From<Tbl>;
+} & {};
+
+/**
+ * A runtime reference to a table. This materializes the RowExpr for us.
+ * TODO: Maybe add the full SchemaDef to the type signature depending on how joins will work.
+ */
+export type TableRef<TableDef extends TypedTableDef> = Readonly<{
+  type: 'table';
+  name: TableDef['name'];
+  cols: RowExpr<TableDef>;
+  indexedCols: IndexedRowExpr<TableDef>;
+  // Maybe redundant.
+  tableDef: TableDef;
+}>;
+
+class TableRefImpl<TableDef extends TypedTableDef>
+  implements TableRef<TableDef>, From<TableDef>
+{
+  readonly type = 'table' as const;
+  name: string;
+  cols: RowExpr<TableDef>;
+  indexedCols: IndexedRowExpr<TableDef>;
+  tableDef: TableDef;
+  constructor(tableDef: TableDef) {
+    this.name = tableDef.name;
+    this.cols = createRowExpr(tableDef);
+    // this.indexedCols = createIndexedRowExpr(tableDef, this.cols);
+    // TODO: we could create an indexedRowExpr to avoid having the extra columns.
+    // Right now, the objects we pass will actually have all the columns, but the
+    // type system will consider it an error.
+    this.indexedCols = this.cols;
+    this.tableDef = tableDef;
+    Object.freeze(this);
+  }
+
+  asFrom(): FromBuilder<TableDef> {
+    return new FromBuilder<TableDef>(this);
+  }
+
+  rightSemijoin<RightTable extends TypedTableDef>(
+    other: TableRef<RightTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<RightTable>
+    ) => EqExpr<TableDef | RightTable>
+  ): SemijoinBuilder<RightTable> {
+    return this.asFrom().rightSemijoin(other, on);
+  }
+
+  leftSemijoin<RightTable extends TypedTableDef>(
+    other: TableRef<RightTable>,
+    on: (
+      left: IndexedRowExpr<TableDef>,
+      right: IndexedRowExpr<RightTable>
+    ) => EqExpr<TableDef | RightTable>
+  ): SemijoinBuilder<TableDef> {
+    return this.asFrom().leftSemijoin(other, on);
+  }
+
+  build(): Query<TableDef> {
+    return this.asFrom().build();
+  }
+
+  toSql(): string {
+    return this.asFrom().toSql();
+  }
+
+  where(
+    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
+  ): FromBuilder<TableDef> {
+    return this.asFrom().where(predicate);
+  }
+}
+
+export type RefSource<TableDef extends TypedTableDef> =
+  | TableRef<TableDef>
+  | { ref(): TableRef<TableDef> };
+
+export function createTableRefFromDef<TableDef extends TypedTableDef>(
+  tableDef: TableDef
+): TableRef<TableDef> {
+  return new TableRefImpl<TableDef>(tableDef);
+}
+
+export function makeQueryBuilder<SchemaDef extends UntypedSchemaDef>(
+  schema: SchemaDef
+): QueryBuilder<SchemaDef> {
+  const qb = Object.create(null) as QueryBuilder<SchemaDef>;
+  for (const table of schema.tables) {
+    const ref = createTableRefFromDef(
+      table as TableDefByName<SchemaDef, TableNames<SchemaDef>>
+    );
+    (qb as Record<string, TableRef<any>>)[table.name] = ref;
+  }
+  return Object.freeze(qb) as QueryBuilder<SchemaDef>;
+}
+
+function createRowExpr<TableDef extends TypedTableDef>(
+  tableDef: TableDef
+): RowExpr<TableDef> {
+  const row: Record<string, ColumnExpr<TableDef, any>> = {};
+  for (const columnName of Object.keys(tableDef.columns) as Array<
+    keyof TableDef['columns'] & string
+  >) {
+    const columnBuilder = tableDef.columns[columnName];
+    const column = new ColumnExpression<TableDef, typeof columnName>(
+      tableDef.name,
+      columnName,
+      columnBuilder.typeBuilder.algebraicType as InferSpacetimeTypeOfColumn<
+        TableDef,
+        typeof columnName
+      >
+    );
+    row[columnName] = Object.freeze(column);
+  }
+  return Object.freeze(row) as RowExpr<TableDef>;
+}
+
+export function from<TableDef extends TypedTableDef>(
+  source: RefSource<TableDef>
+): From<TableDef> {
+  return new FromBuilder(resolveTableRef(source));
+}
+
+function resolveTableRef<TableDef extends TypedTableDef>(
+  source: RefSource<TableDef>
+): TableRef<TableDef> {
+  if (typeof (source as { ref?: unknown }).ref === 'function') {
+    return (source as { ref(): TableRef<TableDef> }).ref();
+  }
+  return source as TableRef<TableDef>;
+}
+
+function renderSelectSqlWithJoins<Table extends TypedTableDef>(
+  table: TableRef<Table>,
+  where?: BooleanExpr<Table>,
+  extraClauses: readonly string[] = []
+): string {
+  const quotedTable = quoteIdentifier(table.name);
+  const sql = `SELECT * FROM ${quotedTable}`;
+  const clauses: string[] = [];
+  if (where) clauses.push(booleanExprToSql(where));
+  clauses.push(...extraClauses);
+  if (clauses.length === 0) return sql;
+  const whereSql =
+    clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(' AND ');
+  return `${sql} WHERE ${whereSql}`;
+}
+
+// TODO: Just use UntypedTableDef if they end up being the same.
+export type TypedTableDef<
+  Columns extends Record<
+    string,
+    ColumnBuilder<any, any, ColumnMetadata<any>>
+  > = Record<string, ColumnBuilder<any, any, ColumnMetadata<any>>>,
+> = {
+  name: string;
+  columns: Columns;
+  indexes: readonly IndexOpts<any>[];
+  rowType: RowBuilder<Columns>['algebraicType']['value'];
+};
+
+export type TableSchemaAsTableDef<
+  TSchema extends TableSchema<any, any, readonly any[]>,
+> = {
+  name: TSchema['tableName'];
+  columns: TSchema['rowType']['row'];
+  indexes: TSchema['idxs'];
+};
+
+type RowType<TableDef extends TypedTableDef> = {
+  [K in keyof TableDef['columns']]: TableDef['columns'][K] extends ColumnBuilder<
+    infer T,
+    any,
+    any
+  >
+    ? T
+    : never;
+};
+
+// TODO: Consider making a smaller version of these types that doesn't expose the internals.
+// Restricting it later should not break anyone in practice.
+export type ColumnExpr<
+  TableDef extends TypedTableDef,
+  ColumnName extends ColumnNames<TableDef>,
+> = ColumnExpression<TableDef, ColumnName>;
+
+type ColumnSpacetimeType<Col extends ColumnExpr<any, any>> =
+  Col extends ColumnExpr<infer T, infer N>
+    ? InferSpacetimeTypeOfColumn<T, N>
+    : never;
+
+// TODO: This checks that they match, but we also need to make sure that they are comparable types,
+// since you can use product types at all.
+type ColumnSameSpacetime<
+  ThisTable extends TypedTableDef,
+  ThisCol extends ColumnNames<ThisTable>,
+  OtherCol extends ColumnExpr<any, any>,
+> = [InferSpacetimeTypeOfColumn<ThisTable, ThisCol>] extends [
+  ColumnSpacetimeType<OtherCol>,
+]
+  ? [ColumnSpacetimeType<OtherCol>] extends [
+      InferSpacetimeTypeOfColumn<ThisTable, ThisCol>,
+    ]
+    ? OtherCol
+    : never
+  : never;
+
+// Helper to get the table back from a column.
+type ExtractTable<Col extends ColumnExpr<any, any>> =
+  Col extends ColumnExpr<infer T, any> ? T : never;
+
+export class ColumnExpression<
+  TableDef extends TypedTableDef,
+  ColumnName extends ColumnNames<TableDef>,
+> {
+  readonly type = 'column' as const;
+  readonly column: ColumnName;
+  readonly table: TableDef['name'];
+  // phantom: actual runtime value is undefined
+  readonly tsValueType?: RowType<TableDef>[ColumnName];
+  readonly spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>;
+
+  constructor(
+    table: TableDef['name'],
+    column: ColumnName,
+    spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>
+  ) {
+    this.table = table;
+    this.column = column;
+    this.spacetimeType = spacetimeType;
+  }
+
+  eq(literal: LiteralValue & RowType<TableDef>[ColumnName]): EqExpr<TableDef>;
+  eq<OtherCol extends ColumnExpr<any, any>>(
+    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
+  ): EqExpr<TableDef | ExtractTable<OtherCol>>;
+
+  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
+  eq(x: any): any {
+    return {
+      type: 'eq',
+      left: this as unknown as ValueExpr<TableDef, any>,
+      right: normalizeValue(x) as ValueExpr<TableDef, any>,
+    } as EqExpr<TableDef>;
+  }
+
+  lt(
+    literal: LiteralValue & RowType<TableDef>[ColumnName]
+  ): BooleanExpr<TableDef>;
+  lt<OtherCol extends ColumnExpr<any, any>>(
+    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
+  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
+
+  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
+  lt(x: any): any {
+    return {
+      type: 'lt',
+      left: this as unknown as ValueExpr<TableDef, any>,
+      right: normalizeValue(x) as ValueExpr<TableDef, any>,
+    } as BooleanExpr<TableDef>;
+  }
+  lte(
+    literal: LiteralValue & RowType<TableDef>[ColumnName]
+  ): BooleanExpr<TableDef>;
+  lte<OtherCol extends ColumnExpr<any, any>>(
+    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
+  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
+
+  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
+  lte(x: any): any {
+    return {
+      type: 'lte',
+      left: this as unknown as ValueExpr<TableDef, any>,
+      right: normalizeValue(x) as ValueExpr<TableDef, any>,
+    } as BooleanExpr<TableDef>;
+  }
+
+  gt(
+    literal: LiteralValue & RowType<TableDef>[ColumnName]
+  ): BooleanExpr<TableDef>;
+  gt<OtherCol extends ColumnExpr<any, any>>(
+    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
+  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
+
+  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
+  gt(x: any): any {
+    return {
+      type: 'gt',
+      left: this as unknown as ValueExpr<TableDef, any>,
+      right: normalizeValue(x) as ValueExpr<TableDef, any>,
+    } as BooleanExpr<TableDef>;
+  }
+  gte(
+    literal: LiteralValue & RowType<TableDef>[ColumnName]
+  ): BooleanExpr<TableDef>;
+  gte<OtherCol extends ColumnExpr<any, any>>(
+    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
+  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
+
+  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
+  gte(x: any): any {
+    return {
+      type: 'gte',
+      left: this as unknown as ValueExpr<TableDef, any>,
+      right: normalizeValue(x) as ValueExpr<TableDef, any>,
+    } as BooleanExpr<TableDef>;
+  }
+}
+
+/**
+ * Helper to get the spacetime type of a column.
+ */
+type InferSpacetimeTypeOfColumn<
+  TableDef extends TypedTableDef,
+  ColumnName extends ColumnNames<TableDef>,
+> =
+  TableDef['columns'][ColumnName]['typeBuilder'] extends TypeBuilder<
+    any,
+    infer U
+  >
+    ? U
+    : never;
+
+type ColumnNames<TableDef extends TypedTableDef> = keyof RowType<TableDef> &
+  string;
+
+// For composite indexes, we only consider it as an index over the first column in the index.
+type FirstIndexColumn<I extends IndexOpts<any>> =
+  IndexColumns<I> extends readonly [infer Head extends string, ...infer _Rest]
+    ? Head
+    : never;
+
+// Columns that are indexed by something in the indexes: [...] part.
+type ExplicitIndexedColumns<TableDef extends TypedTableDef> =
+  TableDef['indexes'][number] extends infer I
+    ? I extends IndexOpts<ColumnNames<TableDef>>
+      ? FirstIndexColumn<I> & ColumnNames<TableDef>
+      : never
+    : never;
+
+// Columns with an index defined on the column definition.
+type MetadataIndexedColumns<TableDef extends TypedTableDef> = {
+  [K in ColumnNames<TableDef>]: ColumnIndex<
+    K,
+    TableDef['columns'][K]['columnMetadata']
+  > extends never
+    ? never
+    : K;
+}[ColumnNames<TableDef>];
+
+export type IndexedColumnNames<TableDef extends TypedTableDef> =
+  | ExplicitIndexedColumns<TableDef>
+  | MetadataIndexedColumns<TableDef>;
+
+export type IndexedRowExpr<TableDef extends TypedTableDef> = Readonly<{
+  readonly [C in IndexedColumnNames<TableDef>]: ColumnExpr<TableDef, C>;
+}>;
+
+/**
+ * Acts as a row when writing filters for queries. It is a way to get column references.
+ */
+export type RowExpr<TableDef extends TypedTableDef> = Readonly<{
+  readonly [C in ColumnNames<TableDef>]: ColumnExpr<TableDef, C>;
+}>;
+
+/**
+ * Union of ColumnExprs from Table whose spacetimeType is compatible with Value
+ * (produces a union of ColumnExpr<Table, C> for matching columns).
+ */
+export type ColumnExprForValue<Table extends TypedTableDef, Value> = {
+  [C in ColumnNames<Table>]: InferSpacetimeTypeOfColumn<Table, C> extends Value
+    ? ColumnExpr<Table, C>
+    : never;
+}[ColumnNames<Table>];
+
+type LiteralValue =
+  | string
+  | number
+  | bigint
+  | boolean
+  | Identity
+  | ConnectionId;
+
+type ValueLike = LiteralValue | ColumnExpr<any, any> | LiteralExpr<any>;
+type ValueInput<TableDef extends TypedTableDef> =
+  | ValueLike
+  | ValueExpr<TableDef, any>;
+
+export type ValueExpr<TableDef extends TypedTableDef, Value> =
+  | LiteralExpr<Value & LiteralValue>
+  | ColumnExprForValue<TableDef, Value>;
+
+type LiteralExpr<Value> = {
+  type: 'literal';
+  value: Value;
+};
+
+export function literal<Value extends LiteralValue>(
+  value: Value
+): ValueExpr<never, Value> {
+  return { type: 'literal', value };
+}
+
+// This is here to take literal values and wrap them in an AST node.
+function normalizeValue(val: ValueInput<any>): ValueExpr<any, any> {
+  if ((val as LiteralExpr<any>).type === 'literal')
+    return val as LiteralExpr<any>;
+  if (
+    typeof val === 'object' &&
+    val != null &&
+    'type' in (val as any) &&
+    (val as any).type === 'column'
+  ) {
+    return val as ColumnExpr<any, any>;
+  }
+  return literal(val as LiteralValue);
+}
+
+type EqExpr<Table extends TypedTableDef = any> = {
+  type: 'eq';
+  left: ValueExpr<Table, any>;
+  right: ValueExpr<Table, any>;
+} & {
+  _tableType?: Table;
+};
+
+type BooleanExpr<Table extends TypedTableDef> = (
+  | {
+      type: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte';
+      left: ValueExpr<Table, any>;
+      right: ValueExpr<Table, any>;
+    }
+  | {
+      type: 'and';
+      clauses: readonly [
+        BooleanExpr<Table>,
+        BooleanExpr<Table>,
+        ...BooleanExpr<Table>[],
+      ];
+    }
+  | {
+      type: 'or';
+      clauses: readonly [
+        BooleanExpr<Table>,
+        BooleanExpr<Table>,
+        ...BooleanExpr<Table>[],
+      ];
+    }
+  | {
+      type: 'not';
+      clause: BooleanExpr<Table>;
+    }
+) & {
+  _tableType?: Table;
+  // readonly [BooleanExprBrand]: Table?;
+};
+
+export function not<T extends TypedTableDef>(
+  clause: BooleanExpr<T>
+): BooleanExpr<T> {
+  return { type: 'not', clause };
+}
+
+export function and<T extends TypedTableDef>(
+  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
+): BooleanExpr<T> {
+  return { type: 'and', clauses };
+}
+
+export function or<T extends TypedTableDef>(
+  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
+): BooleanExpr<T> {
+  return { type: 'or', clauses };
+}
+
+function booleanExprToSql<Table extends TypedTableDef>(
+  expr: BooleanExpr<Table>,
+  tableAlias?: string
+): string {
+  switch (expr.type) {
+    case 'eq':
+      return `${valueExprToSql(expr.left, tableAlias)} = ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'ne':
+      return `${valueExprToSql(expr.left, tableAlias)} <> ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'gt':
+      return `${valueExprToSql(expr.left, tableAlias)} > ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'gte':
+      return `${valueExprToSql(expr.left, tableAlias)} >= ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'lt':
+      return `${valueExprToSql(expr.left, tableAlias)} < ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'lte':
+      return `${valueExprToSql(expr.left, tableAlias)} <= ${valueExprToSql(expr.right, tableAlias)}`;
+    case 'and':
+      return expr.clauses
+        .map(c => booleanExprToSql(c, tableAlias))
+        .map(wrapInParens)
+        .join(' AND ');
+    case 'or':
+      return expr.clauses
+        .map(c => booleanExprToSql(c, tableAlias))
+        .map(wrapInParens)
+        .join(' OR ');
+    case 'not':
+      return `NOT ${wrapInParens(booleanExprToSql(expr.clause, tableAlias))}`;
+  }
+}
+
+function wrapInParens(sql: string): string {
+  return `(${sql})`;
+}
+
+function valueExprToSql<Table extends TypedTableDef>(
+  expr: ValueExpr<Table, any>,
+  tableAlias?: string
+): string {
+  if (isLiteralExpr(expr)) {
+    return literalValueToSql(expr.value);
+  }
+  const table = tableAlias ?? expr.table;
+  return `${quoteIdentifier(table)}.${quoteIdentifier(expr.column)}`;
+}
+
+function literalValueToSql(value: unknown): string {
+  if (value === null || value === undefined) {
+    return 'NULL';
+  }
+  if (value instanceof Identity || value instanceof ConnectionId) {
+    // We use this hex string syntax.
+    return `0x${value.toHexString()}`;
+  }
+  switch (typeof value) {
+    case 'number':
+    case 'bigint':
+      return String(value);
+    case 'boolean':
+      return value ? 'TRUE' : 'FALSE';
+    case 'string':
+      return `'${value.replace(/'/g, "''")}'`;
+    default:
+      // It might be safer to error here?
+      return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
+  }
+}
+
+function quoteIdentifier(name: string): string {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+
+function isLiteralExpr<Value>(
+  expr: ValueExpr<any, Value>
+): expr is LiteralExpr<Value & LiteralValue> {
+  return (expr as LiteralExpr<Value>).type === 'literal';
+}
+
+// TODO: Fix this.
+function _createIndexedRowExpr<TableDef extends TypedTableDef>(
+  tableDef: TableDef,
+  cols: RowExpr<TableDef>
+): IndexedRowExpr<TableDef> {
+  const indexed = new Set<ColumnNames<TableDef>>();
+  for (const idx of tableDef.indexes) {
+    if ('columns' in idx) {
+      const [first] = idx.columns;
+      if (first) indexed.add(first);
+    } else if ('column' in idx) {
+      indexed.add(idx.column);
+    }
+  }
+  const pickedEntries = [...indexed].map(name => [name, cols[name]]);
+  return Object.freeze(
+    Object.fromEntries(pickedEntries)
+  ) as IndexedRowExpr<TableDef>;
+}
diff --git a/crates/bindings-typescript/src/lib/views.ts b/crates/bindings-typescript/src/lib/views.ts
index 82f9f069393..056f25af665 100644
--- a/crates/bindings-typescript/src/lib/views.ts
+++ b/crates/bindings-typescript/src/lib/views.ts
@@ -21,7 +21,7 @@ import {
   type TypeBuilder,
 } from './type_builders';
 import { bsatnBaseSize, toPascalCase } from './util';
-import { type QueryBuilder, type RowTypedQuery } from '../server/query';
+import { type QueryBuilder, type RowTypedQuery } from './query';
 
 export type ViewCtx<S extends UntypedSchemaDef> = Readonly<{
   sender: Identity;
diff --git a/crates/bindings-typescript/src/sdk/client_api/index.ts b/crates/bindings-typescript/src/sdk/client_api/index.ts
index 584808d7bbe..4b644840997 100644
--- a/crates/bindings-typescript/src/sdk/client_api/index.ts
+++ b/crates/bindings-typescript/src/sdk/client_api/index.ts
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.11.2 (commit 902af09c55b418c987000e739eb176a3368296ca).
+// This was generated using spacetimedb cli version 1.11.3 (commit 007e6f16a6b1b698d6a8df1f08464dda335184db).
 
 /* eslint-disable */
 /* tslint:disable */
@@ -12,6 +12,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -25,6 +26,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -119,7 +121,7 @@ const proceduresSchema = __procedures();
 /** The remote SpacetimeDB module schema, both runtime and type information. */
 const REMOTE_MODULE = {
   versionInfo: {
-    cliVersion: '1.11.2' as const,
+    cliVersion: '1.11.3' as const,
   },
   tables: tablesSchema.schemaType.tables,
   reducers: reducersSchema.reducersType.reducers,
@@ -133,6 +135,10 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> =
+  __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(
   reducersSchema.reducersType.reducers
diff --git a/crates/bindings-typescript/src/sdk/subscription_builder_impl.ts b/crates/bindings-typescript/src/sdk/subscription_builder_impl.ts
index 851b6baffe0..ae3f32071cc 100644
--- a/crates/bindings-typescript/src/sdk/subscription_builder_impl.ts
+++ b/crates/bindings-typescript/src/sdk/subscription_builder_impl.ts
@@ -5,6 +5,7 @@ import type {
 } from './event_context';
 import { EventEmitter } from './event_emitter';
 import type { UntypedRemoteModule } from './spacetime_module';
+import { isRowTypedQuery, toSql, type RowTypedQuery } from '../lib/query';
 
 export class SubscriptionBuilderImpl<RemoteModule extends UntypedRemoteModule> {
   #onApplied?: (ctx: SubscriptionEventContextInterface<RemoteModule>) => void =
@@ -78,15 +79,26 @@ export class SubscriptionBuilderImpl<RemoteModule extends UntypedRemoteModule> {
    * ```
    */
   subscribe(
-    query_sql: string | string[]
+    query_sql: string | RowTypedQuery<any, any>
+  ): SubscriptionHandleImpl<RemoteModule>;
+  subscribe(
+    query_sql: Array<string | RowTypedQuery<any, any>>
+  ): SubscriptionHandleImpl<RemoteModule>;
+  subscribe(
+    query_sql: string | RowTypedQuery<any, any> | Array<string | RowTypedQuery<any, any>>
   ): SubscriptionHandleImpl<RemoteModule> {
     const queries = Array.isArray(query_sql) ? query_sql : [query_sql];
     if (queries.length === 0) {
       throw new Error('Subscriptions must have at least one query');
     }
+    const queryStrings = queries.map(q => {
+      if (typeof q === 'string') return q;
+      if (isRowTypedQuery(q)) return toSql(q);
+      throw new Error('Subscriptions must be SQL strings or typed queries');
+    });
     return new SubscriptionHandleImpl(
       this.db,
-      queries,
+      queryStrings,
       this.#onApplied,
       this.#onError
     );
diff --git a/crates/bindings-typescript/src/server/index.ts b/crates/bindings-typescript/src/server/index.ts
index 2147b4ab7d1..61df4bb591c 100644
--- a/crates/bindings-typescript/src/server/index.ts
+++ b/crates/bindings-typescript/src/server/index.ts
@@ -5,7 +5,7 @@ export { reducers } from '../lib/reducers';
 export { SenderError, SpacetimeHostError, errors } from './errors';
 export { type Reducer, type ReducerCtx } from '../lib/reducers';
 export { type DbView } from './db_view';
-export { and, or, not } from './query';
+export * from './query';
 export type { ProcedureCtx, TransactionCtx } from '../lib/procedures';
 export { toCamelCase } from '../lib/util';
 export { type Uuid } from '../lib/uuid';
diff --git a/crates/bindings-typescript/src/server/query.ts b/crates/bindings-typescript/src/server/query.ts
index 0427e6753e1..afeafcdfe03 100644
--- a/crates/bindings-typescript/src/server/query.ts
+++ b/crates/bindings-typescript/src/server/query.ts
@@ -1,778 +1 @@
-import { ConnectionId } from '../lib/connection_id';
-import { Identity } from '../lib/identity';
-import type { ColumnIndex, IndexColumns, IndexOpts } from '../lib/indexes';
-import type { UntypedSchemaDef } from '../lib/schema';
-import type { TableSchema } from '../lib/table_schema';
-import type {
-  ColumnBuilder,
-  ColumnMetadata,
-  RowBuilder,
-  TypeBuilder,
-} from '../lib/type_builders';
-
-/**
- * Helper to get the set of table names.
- */
-export type TableNames<SchemaDef extends UntypedSchemaDef> =
-  SchemaDef['tables'][number]['name'] & string;
-
-/** helper: pick the table def object from the schema by its name */
-export type TableDefByName<
-  SchemaDef extends UntypedSchemaDef,
-  Name extends TableNames<SchemaDef>,
-> = Extract<SchemaDef['tables'][number], { name: Name }>;
-
-// internal only — NOT exported.
-// This is how we make sure queries are only created with our helpers.
-const QueryBrand = Symbol('QueryBrand');
-
-export interface TableTypedQuery<TableDef extends TypedTableDef> {
-  readonly [QueryBrand]: true;
-  readonly __table?: TableDef;
-}
-
-export interface RowTypedQuery<Row, ST> {
-  readonly [QueryBrand]: true;
-  // Phantom type to track the row type.
-  readonly __row?: Row;
-  readonly __algebraicType?: ST;
-}
-
-export type Query<TableDef extends TypedTableDef> = RowTypedQuery<
-  RowType<TableDef>,
-  TableDef['rowType']
->;
-
-export const isRowTypedQuery = (val: unknown): val is RowTypedQuery<any, any> =>
-  !!val && typeof val === 'object' && QueryBrand in (val as object);
-
-export const isTypedQuery = (val: unknown): val is TableTypedQuery<any> =>
-  !!val && typeof val === 'object' && QueryBrand in (val as object);
-
-export function toSql(q: Query<any>): string {
-  return (q as unknown as { toSql(): string }).toSql();
-}
-
-// A query builder with a single table.
-type From<TableDef extends TypedTableDef> = Readonly<{
-  where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
-  ): From<TableDef>;
-  rightSemijoin<RightTable extends TypedTableDef>(
-    other: TableRef<RightTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<RightTable>
-    ) => EqExpr<TableDef | RightTable>
-  ): SemijoinBuilder<RightTable>;
-  leftSemijoin<RightTable extends TypedTableDef>(
-    other: TableRef<RightTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<RightTable>
-    ) => EqExpr<TableDef | RightTable>
-  ): SemijoinBuilder<TableDef>;
-  build(): Query<TableDef>;
-}>;
-
-// A query builder with a semijoin.
-type SemijoinBuilder<TableDef extends TypedTableDef> = Readonly<{
-  where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
-  ): SemijoinBuilder<TableDef>;
-  build(): Query<TableDef>;
-}>;
-
-class SemijoinImpl<TableDef extends TypedTableDef>
-  implements SemijoinBuilder<TableDef>, TableTypedQuery<TableDef>
-{
-  readonly [QueryBrand] = true;
-  readonly type = 'semijoin' as const;
-  constructor(
-    readonly sourceQuery: FromBuilder<TableDef>,
-    readonly filterQuery: FromBuilder<any>,
-    readonly joinCondition: EqExpr<any>
-  ) {
-    if (sourceQuery.table.name === filterQuery.table.name) {
-      // TODO: Handle aliasing properly instead of just forbidding it.
-      throw new Error('Cannot semijoin a table to itself');
-    }
-  }
-
-  build(): Query<TableDef> {
-    return this as Query<TableDef>;
-  }
-
-  where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
-  ): SemijoinImpl<TableDef> {
-    const nextSourceQuery = this.sourceQuery.where(predicate);
-    return new SemijoinImpl<TableDef>(
-      nextSourceQuery,
-      this.filterQuery,
-      this.joinCondition
-    );
-  }
-
-  toSql(): string {
-    const left = this.filterQuery;
-    const right = this.sourceQuery;
-    const leftTable = quoteIdentifier(left.table.name);
-    const rightTable = quoteIdentifier(right.table.name);
-    let sql = `SELECT ${rightTable}.* FROM ${leftTable} JOIN ${rightTable} ON ${booleanExprToSql(this.joinCondition)}`;
-
-    const clauses: string[] = [];
-    if (left.whereClause) {
-      clauses.push(booleanExprToSql(left.whereClause));
-    }
-    if (right.whereClause) {
-      clauses.push(booleanExprToSql(right.whereClause));
-    }
-
-    if (clauses.length > 0) {
-      const whereSql =
-        clauses.length === 1
-          ? clauses[0]
-          : clauses.map(wrapInParens).join(' AND ');
-      sql += ` WHERE ${whereSql}`;
-    }
-
-    return sql;
-  }
-}
-
-class FromBuilder<TableDef extends TypedTableDef>
-  implements From<TableDef>, TableTypedQuery<TableDef>
-{
-  readonly [QueryBrand] = true;
-  constructor(
-    readonly table: TableRef<TableDef>,
-    readonly whereClause?: BooleanExpr<TableDef>
-  ) {}
-
-  where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
-  ): FromBuilder<TableDef> {
-    const newCondition = predicate(this.table.cols);
-    const nextWhere = this.whereClause
-      ? and(this.whereClause, newCondition)
-      : newCondition;
-    return new FromBuilder<TableDef>(this.table, nextWhere);
-  }
-
-  rightSemijoin<OtherTable extends TypedTableDef>(
-    right: TableRef<OtherTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<OtherTable>
-    ) => EqExpr<TableDef | OtherTable>
-  ): SemijoinBuilder<OtherTable> {
-    const sourceQuery = new FromBuilder(right);
-    const joinCondition = on(
-      this.table.indexedCols,
-      right.indexedCols
-    ) as EqExpr<any>;
-    return new SemijoinImpl<OtherTable>(sourceQuery, this, joinCondition);
-  }
-
-  leftSemijoin<OtherTable extends TypedTableDef>(
-    right: TableRef<OtherTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<OtherTable>
-    ) => EqExpr<TableDef | OtherTable>
-  ): SemijoinBuilder<TableDef> {
-    const filterQuery = new FromBuilder(right);
-    const joinCondition = on(
-      this.table.indexedCols,
-      right.indexedCols
-    ) as EqExpr<any>;
-    return new SemijoinImpl<TableDef>(this, filterQuery, joinCondition);
-  }
-
-  toSql(): string {
-    return renderSelectSqlWithJoins(this.table, this.whereClause);
-  }
-
-  build(): Query<TableDef> {
-    return this as Query<TableDef>;
-  }
-}
-
-export type QueryBuilder<SchemaDef extends UntypedSchemaDef> = {
-  readonly [Tbl in SchemaDef['tables'][number] as Tbl['name']]: TableRef<Tbl> &
-    From<Tbl>;
-} & {};
-
-/**
- * A runtime reference to a table. This materializes the RowExpr for us.
- * TODO: Maybe add the full SchemaDef to the type signature depending on how joins will work.
- */
-export type TableRef<TableDef extends TypedTableDef> = Readonly<{
-  type: 'table';
-  name: TableDef['name'];
-  cols: RowExpr<TableDef>;
-  indexedCols: IndexedRowExpr<TableDef>;
-  // Maybe redundant.
-  tableDef: TableDef;
-}>;
-
-class TableRefImpl<TableDef extends TypedTableDef>
-  implements TableRef<TableDef>, From<TableDef>
-{
-  readonly type = 'table' as const;
-  name: string;
-  cols: RowExpr<TableDef>;
-  indexedCols: IndexedRowExpr<TableDef>;
-  tableDef: TableDef;
-  constructor(tableDef: TableDef) {
-    this.name = tableDef.name;
-    this.cols = createRowExpr(tableDef);
-    // this.indexedCols = createIndexedRowExpr(tableDef, this.cols);
-    // TODO: we could create an indexedRowExpr to avoid having the extra columns.
-    // Right now, the objects we pass will actually have all the columns, but the
-    // type system will consider it an error.
-    this.indexedCols = this.cols;
-    this.tableDef = tableDef;
-    Object.freeze(this);
-  }
-
-  asFrom(): FromBuilder<TableDef> {
-    return new FromBuilder<TableDef>(this);
-  }
-
-  rightSemijoin<RightTable extends TypedTableDef>(
-    other: TableRef<RightTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<RightTable>
-    ) => EqExpr<TableDef | RightTable>
-  ): SemijoinBuilder<RightTable> {
-    return this.asFrom().rightSemijoin(other, on);
-  }
-
-  leftSemijoin<RightTable extends TypedTableDef>(
-    other: TableRef<RightTable>,
-    on: (
-      left: IndexedRowExpr<TableDef>,
-      right: IndexedRowExpr<RightTable>
-    ) => EqExpr<TableDef | RightTable>
-  ): SemijoinBuilder<TableDef> {
-    return this.asFrom().leftSemijoin(other, on);
-  }
-
-  build(): Query<TableDef> {
-    return this.asFrom().build();
-  }
-
-  toSql(): string {
-    return this.asFrom().toSql();
-  }
-
-  where(
-    predicate: (row: RowExpr<TableDef>) => BooleanExpr<TableDef>
-  ): FromBuilder<TableDef> {
-    return this.asFrom().where(predicate);
-  }
-}
-
-export type RefSource<TableDef extends TypedTableDef> =
-  | TableRef<TableDef>
-  | { ref(): TableRef<TableDef> };
-
-export function createTableRefFromDef<TableDef extends TypedTableDef>(
-  tableDef: TableDef
-): TableRef<TableDef> {
-  return new TableRefImpl<TableDef>(tableDef);
-}
-
-export function makeQueryBuilder<SchemaDef extends UntypedSchemaDef>(
-  schema: SchemaDef
-): QueryBuilder<SchemaDef> {
-  const qb = Object.create(null) as QueryBuilder<SchemaDef>;
-  for (const table of schema.tables) {
-    const ref = createTableRefFromDef(
-      table as TableDefByName<SchemaDef, TableNames<SchemaDef>>
-    );
-    (qb as Record<string, TableRef<any>>)[table.name] = ref;
-  }
-  return Object.freeze(qb) as QueryBuilder<SchemaDef>;
-}
-
-function createRowExpr<TableDef extends TypedTableDef>(
-  tableDef: TableDef
-): RowExpr<TableDef> {
-  const row: Record<string, ColumnExpr<TableDef, any>> = {};
-  for (const columnName of Object.keys(tableDef.columns) as Array<
-    keyof TableDef['columns'] & string
-  >) {
-    const columnBuilder = tableDef.columns[columnName];
-    const column = new ColumnExpression<TableDef, typeof columnName>(
-      tableDef.name,
-      columnName,
-      columnBuilder.typeBuilder.algebraicType as InferSpacetimeTypeOfColumn<
-        TableDef,
-        typeof columnName
-      >
-    );
-    row[columnName] = Object.freeze(column);
-  }
-  return Object.freeze(row) as RowExpr<TableDef>;
-}
-
-export function from<TableDef extends TypedTableDef>(
-  source: RefSource<TableDef>
-): From<TableDef> {
-  return new FromBuilder(resolveTableRef(source));
-}
-
-function resolveTableRef<TableDef extends TypedTableDef>(
-  source: RefSource<TableDef>
-): TableRef<TableDef> {
-  if (typeof (source as { ref?: unknown }).ref === 'function') {
-    return (source as { ref(): TableRef<TableDef> }).ref();
-  }
-  return source as TableRef<TableDef>;
-}
-
-function renderSelectSqlWithJoins<Table extends TypedTableDef>(
-  table: TableRef<Table>,
-  where?: BooleanExpr<Table>,
-  extraClauses: readonly string[] = []
-): string {
-  const quotedTable = quoteIdentifier(table.name);
-  const sql = `SELECT * FROM ${quotedTable}`;
-  const clauses: string[] = [];
-  if (where) clauses.push(booleanExprToSql(where));
-  clauses.push(...extraClauses);
-  if (clauses.length === 0) return sql;
-  const whereSql =
-    clauses.length === 1 ? clauses[0] : clauses.map(wrapInParens).join(' AND ');
-  return `${sql} WHERE ${whereSql}`;
-}
-
-// TODO: Just use UntypedTableDef if they end up being the same.
-export type TypedTableDef<
-  Columns extends Record<
-    string,
-    ColumnBuilder<any, any, ColumnMetadata<any>>
-  > = Record<string, ColumnBuilder<any, any, ColumnMetadata<any>>>,
-> = {
-  name: string;
-  columns: Columns;
-  indexes: readonly IndexOpts<any>[];
-  rowType: RowBuilder<Columns>['algebraicType']['value'];
-};
-
-export type TableSchemaAsTableDef<
-  TSchema extends TableSchema<any, any, readonly any[]>,
-> = {
-  name: TSchema['tableName'];
-  columns: TSchema['rowType']['row'];
-  indexes: TSchema['idxs'];
-};
-
-type RowType<TableDef extends TypedTableDef> = {
-  [K in keyof TableDef['columns']]: TableDef['columns'][K] extends ColumnBuilder<
-    infer T,
-    any,
-    any
-  >
-    ? T
-    : never;
-};
-
-// TODO: Consider making a smaller version of these types that doesn't expose the internals.
-// Restricting it later should not break anyone in practice.
-export type ColumnExpr<
-  TableDef extends TypedTableDef,
-  ColumnName extends ColumnNames<TableDef>,
-> = ColumnExpression<TableDef, ColumnName>;
-
-type ColumnSpacetimeType<Col extends ColumnExpr<any, any>> =
-  Col extends ColumnExpr<infer T, infer N>
-    ? InferSpacetimeTypeOfColumn<T, N>
-    : never;
-
-// TODO: This checks that they match, but we also need to make sure that they are comparable types,
-// since you can use product types at all.
-type ColumnSameSpacetime<
-  ThisTable extends TypedTableDef,
-  ThisCol extends ColumnNames<ThisTable>,
-  OtherCol extends ColumnExpr<any, any>,
-> = [InferSpacetimeTypeOfColumn<ThisTable, ThisCol>] extends [
-  ColumnSpacetimeType<OtherCol>,
-]
-  ? [ColumnSpacetimeType<OtherCol>] extends [
-      InferSpacetimeTypeOfColumn<ThisTable, ThisCol>,
-    ]
-    ? OtherCol
-    : never
-  : never;
-
-// Helper to get the table back from a column.
-type ExtractTable<Col extends ColumnExpr<any, any>> =
-  Col extends ColumnExpr<infer T, any> ? T : never;
-
-export class ColumnExpression<
-  TableDef extends TypedTableDef,
-  ColumnName extends ColumnNames<TableDef>,
-> {
-  readonly type = 'column' as const;
-  readonly column: ColumnName;
-  readonly table: TableDef['name'];
-  // phantom: actual runtime value is undefined
-  readonly tsValueType?: RowType<TableDef>[ColumnName];
-  readonly spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>;
-
-  constructor(
-    table: TableDef['name'],
-    column: ColumnName,
-    spacetimeType: InferSpacetimeTypeOfColumn<TableDef, ColumnName>
-  ) {
-    this.table = table;
-    this.column = column;
-    this.spacetimeType = spacetimeType;
-  }
-
-  eq(literal: LiteralValue & RowType<TableDef>[ColumnName]): EqExpr<TableDef>;
-  eq<OtherCol extends ColumnExpr<any, any>>(
-    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
-  ): EqExpr<TableDef | ExtractTable<OtherCol>>;
-
-  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
-  eq(x: any): any {
-    return {
-      type: 'eq',
-      left: this as unknown as ValueExpr<TableDef, any>,
-      right: normalizeValue(x) as ValueExpr<TableDef, any>,
-    } as EqExpr<TableDef>;
-  }
-
-  lt(
-    literal: LiteralValue & RowType<TableDef>[ColumnName]
-  ): BooleanExpr<TableDef>;
-  lt<OtherCol extends ColumnExpr<any, any>>(
-    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
-  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
-
-  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
-  lt(x: any): any {
-    return {
-      type: 'lt',
-      left: this as unknown as ValueExpr<TableDef, any>,
-      right: normalizeValue(x) as ValueExpr<TableDef, any>,
-    } as BooleanExpr<TableDef>;
-  }
-  lte(
-    literal: LiteralValue & RowType<TableDef>[ColumnName]
-  ): BooleanExpr<TableDef>;
-  lte<OtherCol extends ColumnExpr<any, any>>(
-    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
-  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
-
-  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
-  lte(x: any): any {
-    return {
-      type: 'lte',
-      left: this as unknown as ValueExpr<TableDef, any>,
-      right: normalizeValue(x) as ValueExpr<TableDef, any>,
-    } as BooleanExpr<TableDef>;
-  }
-
-  gt(
-    literal: LiteralValue & RowType<TableDef>[ColumnName]
-  ): BooleanExpr<TableDef>;
-  gt<OtherCol extends ColumnExpr<any, any>>(
-    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
-  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
-
-  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
-  gt(x: any): any {
-    return {
-      type: 'gt',
-      left: this as unknown as ValueExpr<TableDef, any>,
-      right: normalizeValue(x) as ValueExpr<TableDef, any>,
-    } as BooleanExpr<TableDef>;
-  }
-  gte(
-    literal: LiteralValue & RowType<TableDef>[ColumnName]
-  ): BooleanExpr<TableDef>;
-  gte<OtherCol extends ColumnExpr<any, any>>(
-    value: ColumnSameSpacetime<TableDef, ColumnName, OtherCol>
-  ): BooleanExpr<TableDef | ExtractTable<OtherCol>>;
-
-  // These types could be tighted, but since we declare the overloads above, it doesn't weaken the API surface.
-  gte(x: any): any {
-    return {
-      type: 'gte',
-      left: this as unknown as ValueExpr<TableDef, any>,
-      right: normalizeValue(x) as ValueExpr<TableDef, any>,
-    } as BooleanExpr<TableDef>;
-  }
-}
-
-/**
- * Helper to get the spacetime type of a column.
- */
-type InferSpacetimeTypeOfColumn<
-  TableDef extends TypedTableDef,
-  ColumnName extends ColumnNames<TableDef>,
-> =
-  TableDef['columns'][ColumnName]['typeBuilder'] extends TypeBuilder<
-    any,
-    infer U
-  >
-    ? U
-    : never;
-
-type ColumnNames<TableDef extends TypedTableDef> = keyof RowType<TableDef> &
-  string;
-
-// For composite indexes, we only consider it as an index over the first column in the index.
-type FirstIndexColumn<I extends IndexOpts<any>> =
-  IndexColumns<I> extends readonly [infer Head extends string, ...infer _Rest]
-    ? Head
-    : never;
-
-// Columns that are indexed by something in the indexes: [...] part.
-type ExplicitIndexedColumns<TableDef extends TypedTableDef> =
-  TableDef['indexes'][number] extends infer I
-    ? I extends IndexOpts<ColumnNames<TableDef>>
-      ? FirstIndexColumn<I> & ColumnNames<TableDef>
-      : never
-    : never;
-
-// Columns with an index defined on the column definition.
-type MetadataIndexedColumns<TableDef extends TypedTableDef> = {
-  [K in ColumnNames<TableDef>]: ColumnIndex<
-    K,
-    TableDef['columns'][K]['columnMetadata']
-  > extends never
-    ? never
-    : K;
-}[ColumnNames<TableDef>];
-
-export type IndexedColumnNames<TableDef extends TypedTableDef> =
-  | ExplicitIndexedColumns<TableDef>
-  | MetadataIndexedColumns<TableDef>;
-
-export type IndexedRowExpr<TableDef extends TypedTableDef> = Readonly<{
-  readonly [C in IndexedColumnNames<TableDef>]: ColumnExpr<TableDef, C>;
-}>;
-
-/**
- * Acts as a row when writing filters for queries. It is a way to get column references.
- */
-export type RowExpr<TableDef extends TypedTableDef> = Readonly<{
-  readonly [C in ColumnNames<TableDef>]: ColumnExpr<TableDef, C>;
-}>;
-
-/**
- * Union of ColumnExprs from Table whose spacetimeType is compatible with Value
- * (produces a union of ColumnExpr<Table, C> for matching columns).
- */
-export type ColumnExprForValue<Table extends TypedTableDef, Value> = {
-  [C in ColumnNames<Table>]: InferSpacetimeTypeOfColumn<Table, C> extends Value
-    ? ColumnExpr<Table, C>
-    : never;
-}[ColumnNames<Table>];
-
-type LiteralValue =
-  | string
-  | number
-  | bigint
-  | boolean
-  | Identity
-  | ConnectionId;
-
-type ValueLike = LiteralValue | ColumnExpr<any, any> | LiteralExpr<any>;
-type ValueInput<TableDef extends TypedTableDef> =
-  | ValueLike
-  | ValueExpr<TableDef, any>;
-
-export type ValueExpr<TableDef extends TypedTableDef, Value> =
-  | LiteralExpr<Value & LiteralValue>
-  | ColumnExprForValue<TableDef, Value>;
-
-type LiteralExpr<Value> = {
-  type: 'literal';
-  value: Value;
-};
-
-export function literal<Value extends LiteralValue>(
-  value: Value
-): ValueExpr<never, Value> {
-  return { type: 'literal', value };
-}
-
-// This is here to take literal values and wrap them in an AST node.
-function normalizeValue(val: ValueInput<any>): ValueExpr<any, any> {
-  if ((val as LiteralExpr<any>).type === 'literal')
-    return val as LiteralExpr<any>;
-  if (
-    typeof val === 'object' &&
-    val != null &&
-    'type' in (val as any) &&
-    (val as any).type === 'column'
-  ) {
-    return val as ColumnExpr<any, any>;
-  }
-  return literal(val as LiteralValue);
-}
-
-type EqExpr<Table extends TypedTableDef = any> = {
-  type: 'eq';
-  left: ValueExpr<Table, any>;
-  right: ValueExpr<Table, any>;
-} & {
-  _tableType?: Table;
-};
-
-type BooleanExpr<Table extends TypedTableDef> = (
-  | {
-      type: 'eq' | 'ne' | 'gt' | 'lt' | 'gte' | 'lte';
-      left: ValueExpr<Table, any>;
-      right: ValueExpr<Table, any>;
-    }
-  | {
-      type: 'and';
-      clauses: readonly [
-        BooleanExpr<Table>,
-        BooleanExpr<Table>,
-        ...BooleanExpr<Table>[],
-      ];
-    }
-  | {
-      type: 'or';
-      clauses: readonly [
-        BooleanExpr<Table>,
-        BooleanExpr<Table>,
-        ...BooleanExpr<Table>[],
-      ];
-    }
-  | {
-      type: 'not';
-      clause: BooleanExpr<Table>;
-    }
-) & {
-  _tableType?: Table;
-  // readonly [BooleanExprBrand]: Table?;
-};
-
-export function not<T extends TypedTableDef>(
-  clause: BooleanExpr<T>
-): BooleanExpr<T> {
-  return { type: 'not', clause };
-}
-
-export function and<T extends TypedTableDef>(
-  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
-): BooleanExpr<T> {
-  return { type: 'and', clauses };
-}
-
-export function or<T extends TypedTableDef>(
-  ...clauses: readonly [BooleanExpr<T>, BooleanExpr<T>, ...BooleanExpr<T>[]]
-): BooleanExpr<T> {
-  return { type: 'or', clauses };
-}
-
-function booleanExprToSql<Table extends TypedTableDef>(
-  expr: BooleanExpr<Table>,
-  tableAlias?: string
-): string {
-  switch (expr.type) {
-    case 'eq':
-      return `${valueExprToSql(expr.left, tableAlias)} = ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'ne':
-      return `${valueExprToSql(expr.left, tableAlias)} <> ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'gt':
-      return `${valueExprToSql(expr.left, tableAlias)} > ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'gte':
-      return `${valueExprToSql(expr.left, tableAlias)} >= ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'lt':
-      return `${valueExprToSql(expr.left, tableAlias)} < ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'lte':
-      return `${valueExprToSql(expr.left, tableAlias)} <= ${valueExprToSql(expr.right, tableAlias)}`;
-    case 'and':
-      return expr.clauses
-        .map(c => booleanExprToSql(c, tableAlias))
-        .map(wrapInParens)
-        .join(' AND ');
-    case 'or':
-      return expr.clauses
-        .map(c => booleanExprToSql(c, tableAlias))
-        .map(wrapInParens)
-        .join(' OR ');
-    case 'not':
-      return `NOT ${wrapInParens(booleanExprToSql(expr.clause, tableAlias))}`;
-  }
-}
-
-function wrapInParens(sql: string): string {
-  return `(${sql})`;
-}
-
-function valueExprToSql<Table extends TypedTableDef>(
-  expr: ValueExpr<Table, any>,
-  tableAlias?: string
-): string {
-  if (isLiteralExpr(expr)) {
-    return literalValueToSql(expr.value);
-  }
-  const table = tableAlias ?? expr.table;
-  return `${quoteIdentifier(table)}.${quoteIdentifier(expr.column)}`;
-}
-
-function literalValueToSql(value: unknown): string {
-  if (value === null || value === undefined) {
-    return 'NULL';
-  }
-  if (value instanceof Identity || value instanceof ConnectionId) {
-    // We use this hex string syntax.
-    return `0x${value.toHexString()}`;
-  }
-  switch (typeof value) {
-    case 'number':
-    case 'bigint':
-      return String(value);
-    case 'boolean':
-      return value ? 'TRUE' : 'FALSE';
-    case 'string':
-      return `'${value.replace(/'/g, "''")}'`;
-    default:
-      // It might be safer to error here?
-      return `'${JSON.stringify(value).replace(/'/g, "''")}'`;
-  }
-}
-
-function quoteIdentifier(name: string): string {
-  return `"${name.replace(/"/g, '""')}"`;
-}
-
-function isLiteralExpr<Value>(
-  expr: ValueExpr<any, Value>
-): expr is LiteralExpr<Value & LiteralValue> {
-  return (expr as LiteralExpr<Value>).type === 'literal';
-}
-
-// TODO: Fix this.
-function _createIndexedRowExpr<TableDef extends TypedTableDef>(
-  tableDef: TableDef,
-  cols: RowExpr<TableDef>
-): IndexedRowExpr<TableDef> {
-  const indexed = new Set<ColumnNames<TableDef>>();
-  for (const idx of tableDef.indexes) {
-    if ('columns' in idx) {
-      const [first] = idx.columns;
-      if (first) indexed.add(first);
-    } else if ('column' in idx) {
-      indexed.add(idx.column);
-    }
-  }
-  const pickedEntries = [...indexed].map(name => [name, cols[name]]);
-  return Object.freeze(
-    Object.fromEntries(pickedEntries)
-  ) as IndexedRowExpr<TableDef>;
-}
+export * from '../lib/query';
diff --git a/crates/bindings-typescript/test-app/src/main.tsx b/crates/bindings-typescript/test-app/src/main.tsx
index 028148b3eb7..fb1ac03c242 100644
--- a/crates/bindings-typescript/test-app/src/main.tsx
+++ b/crates/bindings-typescript/test-app/src/main.tsx
@@ -3,7 +3,7 @@ import ReactDOM from 'react-dom/client';
 import App from './App.tsx';
 import './index.css';
 import { SpacetimeDBProvider } from '../../src/react';
-import { DbConnection } from './module_bindings/index.ts';
+import { DbConnection, query } from './module_bindings/index.ts';
 
 const connectionBuilder = DbConnection.builder()
   .withUri('ws://localhost:3000')
@@ -21,7 +21,7 @@ const connectionBuilder = DbConnection.builder()
       identity.toHexString()
     );
 
-    conn.subscriptionBuilder().subscribe('SELECT * FROM player');
+    conn.subscriptionBuilder().subscribe(query.player.build());
   });
 
 ReactDOM.createRoot(document.getElementById('root')!).render(
diff --git a/crates/bindings-typescript/test-app/src/module_bindings/index.ts b/crates/bindings-typescript/test-app/src/module_bindings/index.ts
index 8a960614437..d0da763d072 100644
--- a/crates/bindings-typescript/test-app/src/module_bindings/index.ts
+++ b/crates/bindings-typescript/test-app/src/module_bindings/index.ts
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.11.2 (commit 902af09c55b418c987000e739eb176a3368296ca).
+// This was generated using spacetimedb cli version 1.11.3 (commit 007e6f16a6b1b698d6a8df1f08464dda335184db).
 
 /* eslint-disable */
 /* tslint:disable */
@@ -12,6 +12,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -25,6 +26,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -110,7 +112,7 @@ const proceduresSchema = __procedures();
 /** The remote SpacetimeDB module schema, both runtime and type information. */
 const REMOTE_MODULE = {
   versionInfo: {
-    cliVersion: '1.11.2' as const,
+    cliVersion: '1.11.3' as const,
   },
   tables: tablesSchema.schemaType.tables,
   reducers: reducersSchema.reducersType.reducers,
@@ -124,6 +126,10 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> =
+  __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(
   reducersSchema.reducersType.reducers
diff --git a/crates/bindings-typescript/tests/client_query.test.ts b/crates/bindings-typescript/tests/client_query.test.ts
new file mode 100644
index 00000000000..9c8350ac742
--- /dev/null
+++ b/crates/bindings-typescript/tests/client_query.test.ts
@@ -0,0 +1,233 @@
+import { describe, expect, it } from 'vitest';
+import { Identity } from '../src/lib/identity';
+import { and, not, or, toSql } from '../src/lib/query';
+import { query } from '../test-app/src/module_bindings';
+
+describe('ClientQuery.toSql', () => {
+  it('renders a full-table scan when no filters are applied', () => {
+    const sql = toSql(query.player.build());
+
+    expect(sql).toBe('SELECT * FROM "player"');
+  });
+
+  it('renders a WHERE clause for simple equality filters', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.name.eq("O'Brian"))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" = 'O''Brian'`
+    );
+  });
+
+  it('renders numeric literals and column references', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.id.eq(42))
+        .build()
+    );
+
+    expect(sql).toBe(`SELECT * FROM "player" WHERE "player"."id" = 42`);
+  });
+
+  it('renders AND clauses across multiple predicates', () => {
+    const sql = toSql(
+      query.player
+        .where(row => and(row.name.eq('Alice'), row.id.eq(30)))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE ("player"."name" = 'Alice') AND ("player"."id" = 30)`
+    );
+  });
+
+  it('renders NOT clauses around subpredicates', () => {
+    const sql = toSql(
+      query.player
+        .where(row => not(row.name.eq('Bob')))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE NOT ("player"."name" = 'Bob')`
+    );
+  });
+
+  it('accumulates multiple filters with AND logic', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.name.eq('Eve'))
+        .where(row => row.id.eq(25))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE ("player"."name" = 'Eve') AND ("player"."id" = 25)`
+    );
+  });
+
+  it('renders OR clauses across multiple predicates', () => {
+    const sql = toSql(
+      query.player
+        .where(row => or(row.name.eq('Carol'), row.name.eq('Dave')))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE ("player"."name" = 'Carol') OR ("player"."name" = 'Dave')`
+    );
+  });
+
+  it('renders Identity literals using their hex form', () => {
+    const identity = new Identity(
+      '0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef'
+    );
+    const sql = toSql(
+      query.user
+        .where(row => row.identity.eq(identity))
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT * FROM "user" WHERE "user"."identity" = 0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef`
+    );
+  });
+
+  it('renders semijoin queries without additional filters', () => {
+    const sql = toSql(
+      query.player
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id"`
+    );
+  });
+
+  it('renders semijoin queries alongside existing predicates', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.id.eq(42))
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id" WHERE "player"."id" = 42`
+    );
+  });
+
+  it('escapes literals when rendering semijoin filters', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.name.eq("O'Brian"))
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id" WHERE "player"."name" = 'O''Brian'`
+    );
+  });
+
+  it('renders compound AND filters for semijoin queries', () => {
+    const sql = toSql(
+      query.player
+        .where(row => and(row.name.eq('Alice'), row.id.eq(30)))
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id" WHERE ("player"."name" = 'Alice') AND ("player"."id" = 30)`
+    );
+  });
+
+  it('basic where', () => {
+    const sql = toSql(query.player.where(row => row.name.eq('Gadget')).build());
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" = 'Gadget'`
+    );
+  });
+
+  it('basic where lt', () => {
+    const sql = toSql(query.player.where(row => row.name.lt('Gadget')).build());
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" < 'Gadget'`
+    );
+  });
+
+  it('basic where lte', () => {
+    const sql = toSql(query.player.where(row => row.name.lte('Gadget')).build());
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" <= 'Gadget'`
+    );
+  });
+
+  it('basic where gt', () => {
+    const sql = toSql(query.player.where(row => row.name.gt('Gadget')).build());
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" > 'Gadget'`
+    );
+  });
+
+  it('basic where gte', () => {
+    const sql = toSql(query.player.where(row => row.name.gte('Gadget')).build());
+    expect(sql).toBe(
+      `SELECT * FROM "player" WHERE "player"."name" >= 'Gadget'`
+    );
+  });
+
+  it('basic semijoin', () => {
+    const sql = toSql(
+      query.player
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id"`
+    );
+  });
+
+  it('basic left semijoin', () => {
+    const sql = toSql(
+      query.player
+        .leftSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .build()
+    );
+    expect(sql).toBe(
+      `SELECT "player".* FROM "unindexed_player" JOIN "player" ON "unindexed_player"."id" = "player"."id"`
+    );
+  });
+
+  it('semijoin with filters on both sides', () => {
+    const sql = toSql(
+      query.player
+        .where(row => row.id.eq(42))
+        .rightSemijoin(query.unindexed_player, (player, other) =>
+          other.id.eq(player.id)
+        )
+        .where(row => row.name.eq('Gadget'))
+        .build()
+    );
+    expect(sql).toBe(
+      `SELECT "unindexed_player".* FROM "player" JOIN "unindexed_player" ON "unindexed_player"."id" = "player"."id" WHERE ("player"."id" = 42) AND ("unindexed_player"."name" = 'Gadget')`
+    );
+  });
+});
diff --git a/crates/codegen/src/typescript.rs b/crates/codegen/src/typescript.rs
index 90788903ff3..5059330882a 100644
--- a/crates/codegen/src/typescript.rs
+++ b/crates/codegen/src/typescript.rs
@@ -346,6 +346,12 @@ impl Lang for TypeScript {
             "export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);"
         );
         writeln!(out);
+        writeln!(out, "/** A typed query builder for this remote SpacetimeDB module. */");
+        writeln!(
+            out,
+            "export const query: __QueryBuilder<typeof tablesSchema.schemaType> = __makeQueryBuilder(tablesSchema.schemaType);"
+        );
+        writeln!(out);
         writeln!(out, "/** The reducers available in this remote SpacetimeDB module. */");
         writeln!(
             out,
@@ -455,6 +461,8 @@ fn print_index_imports(out: &mut Indenter) {
         "Uuid as __Uuid",
         "DbConnectionBuilder as __DbConnectionBuilder",
         "convertToAccessorMap as __convertToAccessorMap",
+        "makeQueryBuilder as __makeQueryBuilder",
+        "type QueryBuilder as __QueryBuilder",
         "type EventContextInterface as __EventContextInterface",
         "type ReducerEventContextInterface as __ReducerEventContextInterface",
         "type SubscriptionEventContextInterface as __SubscriptionEventContextInterface",
diff --git a/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap b/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap
index 6ee9962529e..c4fbcde807f 100644
--- a/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap
+++ b/crates/codegen/tests/snapshots/codegen__codegen_typescript.snap
@@ -233,6 +233,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -246,6 +247,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -559,6 +561,9 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> = __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(reducersSchema.reducersType.reducers);
 
diff --git a/templates/basic-react/src/module_bindings/index.ts b/templates/basic-react/src/module_bindings/index.ts
index 5aedda6b8bb..93bd03119cb 100644
--- a/templates/basic-react/src/module_bindings/index.ts
+++ b/templates/basic-react/src/module_bindings/index.ts
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.11.2 (commit 902af09c55b418c987000e739eb176a3368296ca).
+// This was generated using spacetimedb cli version 1.11.3 (commit 007e6f16a6b1b698d6a8df1f08464dda335184db).
 
 /* eslint-disable */
 /* tslint:disable */
@@ -12,6 +12,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -25,6 +26,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -85,7 +87,7 @@ const proceduresSchema = __procedures();
 /** The remote SpacetimeDB module schema, both runtime and type information. */
 const REMOTE_MODULE = {
   versionInfo: {
-    cliVersion: '1.11.2' as const,
+    cliVersion: '1.11.3' as const,
   },
   tables: tablesSchema.schemaType.tables,
   reducers: reducersSchema.reducersType.reducers,
@@ -99,6 +101,10 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> =
+  __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(
   reducersSchema.reducersType.reducers
diff --git a/templates/basic-typescript/src/module_bindings/index.ts b/templates/basic-typescript/src/module_bindings/index.ts
index 5aedda6b8bb..93bd03119cb 100644
--- a/templates/basic-typescript/src/module_bindings/index.ts
+++ b/templates/basic-typescript/src/module_bindings/index.ts
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.11.2 (commit 902af09c55b418c987000e739eb176a3368296ca).
+// This was generated using spacetimedb cli version 1.11.3 (commit 007e6f16a6b1b698d6a8df1f08464dda335184db).
 
 /* eslint-disable */
 /* tslint:disable */
@@ -12,6 +12,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -25,6 +26,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -85,7 +87,7 @@ const proceduresSchema = __procedures();
 /** The remote SpacetimeDB module schema, both runtime and type information. */
 const REMOTE_MODULE = {
   versionInfo: {
-    cliVersion: '1.11.2' as const,
+    cliVersion: '1.11.3' as const,
   },
   tables: tablesSchema.schemaType.tables,
   reducers: reducersSchema.reducersType.reducers,
@@ -99,6 +101,10 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> =
+  __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(
   reducersSchema.reducersType.reducers
diff --git a/templates/quickstart-chat-typescript/src/module_bindings/index.ts b/templates/quickstart-chat-typescript/src/module_bindings/index.ts
index 203c0b496a6..1c38278c8ab 100644
--- a/templates/quickstart-chat-typescript/src/module_bindings/index.ts
+++ b/templates/quickstart-chat-typescript/src/module_bindings/index.ts
@@ -1,7 +1,7 @@
 // THIS FILE IS AUTOMATICALLY GENERATED BY SPACETIMEDB. EDITS TO THIS FILE
 // WILL NOT BE SAVED. MODIFY TABLES IN YOUR MODULE SOURCE CODE INSTEAD.
 
-// This was generated using spacetimedb cli version 1.11.3 (commit 36dac98fda48c2f3961e11d1c11d4121582f7306).
+// This was generated using spacetimedb cli version 1.11.3 (commit 007e6f16a6b1b698d6a8df1f08464dda335184db).
 
 /* eslint-disable */
 /* tslint:disable */
@@ -12,6 +12,7 @@ import {
   TypeBuilder as __TypeBuilder,
   Uuid as __Uuid,
   convertToAccessorMap as __convertToAccessorMap,
+  makeQueryBuilder as __makeQueryBuilder,
   procedureSchema as __procedureSchema,
   procedures as __procedures,
   reducerSchema as __reducerSchema,
@@ -25,6 +26,7 @@ import {
   type Event as __Event,
   type EventContextInterface as __EventContextInterface,
   type Infer as __Infer,
+  type QueryBuilder as __QueryBuilder,
   type ReducerEventContextInterface as __ReducerEventContextInterface,
   type RemoteModule as __RemoteModule,
   type SubscriptionEventContextInterface as __SubscriptionEventContextInterface,
@@ -119,6 +121,10 @@ const REMOTE_MODULE = {
 /** The tables available in this remote SpacetimeDB module. */
 export const tables = __convertToAccessorMap(tablesSchema.schemaType.tables);
 
+/** A typed query builder for this remote SpacetimeDB module. */
+export const query: __QueryBuilder<typeof tablesSchema.schemaType> =
+  __makeQueryBuilder(tablesSchema.schemaType);
+
 /** The reducers available in this remote SpacetimeDB module. */
 export const reducers = __convertToAccessorMap(
   reducersSchema.reducersType.reducers