joist-core 2.3.0-next.99 → 2.4.0

package/build/queries/sql/query.d.mts

@@ -5,8 +5,9 @@ import { EntityMetadata } from "../../EntityMetadata.mjs";
 import { AliasAssigner } from "./AliasAssigner.mjs";
 import { CheckInput, ExprFromInput, ExprInput, ExpressionSources, ExpressionValue } from "./expressions/types.mjs";
 import "./expressions/expression.mjs";
-import { BaseExpr, Expr, ExprContext, ExprLike, InnerJoin, LeftJoin, SqlFragment } from "./Expr.mjs";
-import { Table, TableBrand, referenceJoinSource, tableMgmt } from "./Tables.mjs";
+import { Table, TableBrand, TableFor, TableSourceBrand, referenceJoinSource, tableMgmt } from "./Tables.mjs";
+import { BaseExpr, Expr, ExprContext, ExprLike, InnerJoin, LeftJoin, SqlFragment, selectKeyBrand } from "./Expr.mjs";
+import { CheckJoinInput, TreeEntries } from "./JoinTree.mjs";
 import { Entity } from "../../Entity.mjs";
 //#region src/queries/sql/query.d.ts
 /**
@@ -23,10 +24,10 @@ import { Entity } from "../../Entity.mjs";
  *     select: { name: a.first_name, n: bookStats.n },
  *     orderBy: { n: "DESC" },
  *   });
- *   // rows: { name: string; n: number | null }[]   (null because of the LEFT join)
+ *   // rows: { name: string; n: number | undefined }[]   (undefined because of the LEFT join)
  *
- * `em.query(pojo)` runs it. `select` decides the row type: a bare table returns entities, a
- * `{ key: expr }` object returns typed POJOs, a bare subquery returns that subquery's rows.
+ * `em.query(pojo)` runs it. `select` decides the row type: a bare table returns entities, an array of
+ * columns or a `{ key: expr }` object returns typed POJOs, and a bare subquery returns its rows.
  *
  * `query(pojo)` turns the *same* POJO into a value: a derived table with typed columns, a scalar
  * expression, or an entity list. It is the one non-POJO step, and the subquery analog of `table(Author)`:
@@ -86,6 +87,12 @@ interface SubqueryBrand<R, Name extends string> {
 }
 /** Anything that can be a source or be joined: an entity table or a table-shaped subquery. */
 type QuerySource = {
+  readonly [tableMgmt]: TableSourceBrand<string>;
+} | {
+  readonly [subqueryBrand]: SubqueryBrand<any, string>;
+};
+/** A generated entity table or table-shaped subquery that supports `select: source`. */
+type SelectableQuerySource = {
   readonly [tableMgmt]: TableBrand<any, string>;
 } | {
   readonly [subqueryBrand]: SubqueryBrand<any, string>;
@@ -96,7 +103,14 @@ type QuerySource = {
  * form, since a subquery has no FK metadata.
  */
 type QueryJoin = InnerJoin<QuerySource, QueryCondition> | LeftJoin<QuerySource, QueryCondition>;
-type QueryJoins = readonly (QueryJoin | undefined)[];
+type QueryJoinList = readonly (QueryJoin | undefined)[];
+/** A flat SQL join list or a domain relationship tree rooted at from. */
+type QueryJoinInput = QueryJoinList | Readonly<Record<string, unknown>>;
+/**
+ * Resolves tree bindings to join types for scope and result nullability.
+ * Deferring the extracted entry union avoids expanding recursive constraints in generic query signatures.
+ */
+type ResolvedJoins<F, J> = J extends QueryJoinList ? J : F extends TableFor<infer T extends Entity> ? TreeEntries<T, J> extends (infer E) ? readonly Extract<E, QueryJoin>[] : never : [];
 /**
  * A CTE declaration: a `query(...)` value with named columns, i.e. a POJO or set-operation select.
  *
@@ -111,7 +125,7 @@ interface RecursiveOptions {
   /** Defaults to `"all"`. `"distinct"` emits UNION, which stops a cyclic graph from looping forever. */
   union?: "all" | "distinct";
 }
-/** An expression order-by entry. An undefined order prunes the complete entry. */
+/** An expression order-by entry, also returned by `expr.asc()` and `expr.desc()`. An undefined order prunes it. */
 type ExpressionOrderBy = {
   readonly sort: ExprLike<unknown>;
   readonly order: "ASC" | "DESC" | undefined;
@@ -124,9 +138,9 @@ type OrderByDirection = "ASC" | "DESC" | "ASC NULLS FIRST" | "ASC NULLS LAST" |
  * The keys are the keys of a POJO/subquery `select` (rendered as SQL output-column names, so ordering
  * by an aggregate does not repeat its expression), or the entity's sortable fields in entity mode.
  * An `undefined` direction prunes the entry, like any other condition. For expressions that are not
- * in `select`, mix in `{ sort, order }` entries in the array form.
+ * in `select`, mix in `expr.asc()`/`expr.desc()` or `{ sort, order }` entries in the array form.
  */
-type OrderByKeys<S> = S extends {
+type OrderByKeys<S> = S extends readonly NamedSelectExpression[] ? { readonly [K in SelectKey<S[number]>]?: OrderByDirection | undefined; } : S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T;
   };
@@ -137,12 +151,20 @@ type OrderByKey<S> = S extends unknown ? keyof OrderByKeys<S> : never;
 type CheckedExpressionOrderBy<S> = ExpressionOrderBy & (string extends OrderByKey<S> ? unknown : [S] extends [{
   readonly [tableMgmt]: unknown;
 }] ? unknown : { readonly [K in Exclude<OrderByKey<S>, keyof ExpressionOrderBy>]?: never; });
-/** The three select shapes: a source, an existing scalar expression, or a POJO naming result columns. */
-type QuerySelect = QuerySource | ExprLike<unknown> | Record<string, SelectExpression>;
+/** The select shapes: a source, scalar expression, named column array, or POJO naming result columns. */
+type QuerySelect = SelectableQuerySource | ExprLike<unknown> | readonly NamedSelectExpression[] | Record<string, SelectExpression>;
 /** A named projection value may be an existing expression or an inline expression literal. */
 type SelectExpression = ExprLike<unknown> | ExprInput;
+/** A physical or subquery column that retains the field name used for array-select result rows. */
+type NamedSelectExpression = ExprLike<unknown> & {
+  readonly [selectKeyBrand]: string;
+};
+/** Extracts the table property name carried by a column expression for array selects. */
+type SelectKey<S> = S extends {
+  readonly [selectKeyBrand]: infer K extends string;
+} ? K : never;
 /** Checks expression literals only inside named projections. */
-type CheckSelect<S> = S extends QuerySource | ExprLike<unknown> ? unknown : { readonly [K in keyof S]: S[K] extends ExprInput ? CheckInput<S[K]> : unknown; };
+type CheckSelect<S> = S extends QuerySource | ExprLike<unknown> | readonly NamedSelectExpression[] ? unknown : { readonly [K in keyof S]: S[K] extends ExprInput ? CheckInput<S[K]> : unknown; };
 /**
  * Everything but the source, in SQL evaluation order: FROM/JOIN, WHERE, GROUP BY, HAVING, SELECT,
  * ORDER BY, LIMIT.
@@ -150,7 +172,7 @@ type CheckSelect<S> = S extends QuerySource | ExprLike<unknown> ? unknown : { re
  * `S` and `J` are generic so callers keep the literal shape of `select` and `join`; the defaults let
  * a standalone object use `satisfies Query` (or `satisfies Clauses` for a source-less fragment).
  */
-interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoins = QueryJoins> {
+interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> {
   /**
    * CTEs to include in a `WITH` clause, declared as `query(...)` values; either a single value or an array.
    *
@@ -160,13 +182,18 @@ interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoins = Qu
    * the same pruning `join` gets (see "Pruning"); `pruneJoins: false` keeps every CTE.
    */
   with?: WithInput;
+  /** A flat join list, or a domain relationship tree rooted at the entity table in from. */
   join?: J;
-  /** A boolean group, an exists/notExists query, or a bare condition such as `a.age.gte(18)`. */
-  where?: QueryCondition;
+  /**
+   * An `{ and: [...] }` or `{ or: [...] }` group, an exists/notExists query, or a bare condition such as `a.age.gte(18)`.
+   *
+   * Arrays are shorthand for `{ and: [...] }`; undefined conditions are pruned.
+   */
+  where?: QueryCondition | readonly (QueryCondition | undefined)[];
   groupBy?: readonly ExprLike<any>[];
   having?: QueryCondition;
   select: S;
-  orderBy?: readonly (CheckedExpressionOrderBy<S> | OrderByKeys<S> | undefined)[] | OrderByKeys<S>;
+  orderBy?: readonly (CheckedExpressionOrderBy<S> | OrderByKeys<S> | undefined)[] | CheckedExpressionOrderBy<S> | OrderByKeys<S>;
   limit?: number;
   offset?: number;
   distinct?: boolean;
@@ -181,7 +208,7 @@ interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoins = Qu
   softDeletes?: "include" | "exclude";
 }
 /** A whole query: `Clauses` plus its source. `query(q)` turns it into a value; `em.query(q)` runs it. */
-interface Query<S extends QuerySelect = QuerySelect, J extends QueryJoins = QueryJoins> extends Clauses<S, J>, Partial<Record<SetOperation | MutationKey | "ctes", never>> {
+interface Query<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> extends Clauses<S, J>, Partial<Record<SetOperation | MutationKey | "ctes", never>> {
   from: QuerySource;
 }
 /**
@@ -246,7 +273,7 @@ type FirstOperand<Q> = OperandsOf<Q>[0];
  * Resolves the named rows of an ordinary or compound read operand, including its LEFT join nullability.
  *
  * I.e. a query from Author `a` with a LEFT-joined Book `b` and `select: { title: b.title }` has row type
- * `{ title: string | null }`, even though Book.title is required. A reusable `query(...)` value already
+ * `{ title: string | undefined }`, even though Book.title is required. A reusable `query(...)` value already
  * stores that row type in its brand; a nested compound combines its own operands recursively.
  */
 type ReadQueryRow<Q> = SetOperand extends Q ? unknown : Q extends {
@@ -255,13 +282,13 @@ type ReadQueryRow<Q> = SetOperand extends Q ? unknown : Q extends {
   };
 } ? R : Q extends {
   select: infer S;
-} ? QueryRow<S, "join" extends keyof Q ? Extract<Q[keyof Q & "join"], QueryJoins> : []> : [OperandsOf<Q>] extends [never] ? never : SetQueryRow<Q>;
+} ? QueryRow<S, ResolvedJoins<Q[keyof Q & "from"], "join" extends keyof Q ? Extract<Q[keyof Q & "join"], QueryJoinInput> : []>> : [OperandsOf<Q>] extends [never] ? never : SetQueryRow<Q>;
 /**
  * UNION combines each column's values; INTERSECT and EXCEPT conservatively retain the left row.
  *
  * I.e. Author first names projected as `{ name: string }` unioned with LEFT-joined Book titles projected
- * as `{ name: string | null }` produce `{ name: string | null }`. EXCEPT with those Author names on the
- * left retains `{ name: string }`; it neither adds the right side's NULL nor promises narrower values.
+ * as `{ name: string | undefined }` produce `{ name: string | undefined }`. EXCEPT with those Author names on
+ * the left retains `{ name: string }`; it neither adds the right side's absence nor promises narrower values.
  *
  * The outer conditional distributes over a TypeScript union of alternative queries. I.e. a runtime
  * choice between an Author-name UNION and a Book-order EXCEPT must retain `{ name: string } | { order: number }`.
@@ -343,7 +370,7 @@ type CheckReadQuery<Q> = SetOperand extends Q ? unknown : Q extends readonly unk
 } ? { readonly [K in keyof Q]: K extends typeof entityQueryBrand ? unknown : never; } : Q extends {
   readonly from: unknown;
   readonly select: unknown;
-} ? { readonly [K in keyof Q]: K extends "select" ? CheckSelect<Q[K]> : K extends keyof Clauses | "from" | "as" ? unknown : never; } : { readonly [K in keyof Q]: K extends SetOperation ? Q[K] extends readonly unknown[] ? CheckReadQuery<Q[K]> : unknown : K extends "with" | "orderBy" | "limit" | "offset" | "as" ? unknown : never; };
+} ? CheckJoinInput<Q["from"], "join" extends keyof Q ? Exclude<Q[keyof Q & "join"], undefined> : []> & { readonly [K in keyof Q]: K extends "select" ? CheckSelect<Q[K]> : K extends keyof Clauses | "from" | "as" ? unknown : never; } : { readonly [K in keyof Q]: K extends SetOperation ? Q[K] extends readonly unknown[] ? CheckReadQuery<Q[K]> : unknown : K extends "with" | "orderBy" | "limit" | "offset" | "as" ? unknown : never; };
 /** The type-level name of a table or subquery, i.e. `"Author"` or `"book_stats"`. */
 type NameOf<A> = A extends {
   readonly [tableMgmt]: {
@@ -369,30 +396,31 @@ type InheritedLeft<X, Left> = X extends {
 type NullableSources<X, Left = LeftJoined<X>> = [Exclude<InheritedLeft<X, Left>, Left>] extends [never] ? Left : NullableSources<X, Left | InheritedLeft<X, Left>>;
 /**
  * Asks: is this expression's source key among the LEFT-joined sources in this query's join list? If
- * yes, the value can be `null`, so `R` becomes `R | null`; if no, `R` is unchanged.
+ * yes, SQL can return NULL, so `R` becomes `R | null`; if no, `R` is unchanged.
  *
  * I.e. `MaybeNull<number, "book_stats", [LeftJoin<typeof bookStats>]>` is `number | null`,
  * because `book_stats` is in `NullableSources<J[number]>`; with an inner join it stays `number`.
  * Default references from nullable sources are included transitively.
  *
  * Source-less expressions (`Src` is `never`, i.e. `b.id.count()`) are never nullified. Untracked ones
- * (`Src` is `string`, i.e. a `sql.ref` on an unknown table) might come from any left-joined table,
+ * (`Src` is `string`, i.e. a table whose entity type is not statically known) might come from any left-joined table,
  * so they are conservatively nullified whenever the query has a left join at all.
  *
  * `string` must never be a *table's* name: `Extract<"Author", string>` matches, so one left-joined
  * table named `string` would nullify every column in the query. That is why anonymous subqueries
  * share the literal sentinel `"?"` instead.
  */
-type MaybeNull<R, Src extends string, J extends QueryJoins> = string extends Src ? [NullableSources<J[number]>] extends [never] ? R : R | null : [Extract<Src, NullableSources<J[number]>>] extends [never] ? R : R | null;
+type MaybeNull<R, Src extends string, J extends QueryJoinList> = string extends Src ? [NullableSources<J[number]>] extends [never] ? R : R | null : [Extract<Src, NullableSources<J[number]>>] extends [never] ? R : R | null;
 /**
  * The result row for a query with select `S` and joins `J`.
  *
  * - entity mode (`select: a`) is the entity
  * - subquery mode (`select: bookStats`) is the subquery's row, i.e. `select *`
  * - single expression (`select: b.id.count()`) is that expression's value, used by scalar subqueries
+ * - column array mode uses each column's field name as the result key
  * - POJO mode is a mapped type over the select keys, with left-join nullability applied
  */
-type QueryRow<S, J extends QueryJoins = []> = S extends {
+type QueryRow<S, J extends QueryJoinList = []> = S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T;
   };
@@ -400,7 +428,25 @@ type QueryRow<S, J extends QueryJoins = []> = S extends {
   readonly [subqueryBrand]: {
     readonly __row: infer R;
   };
-} ? R : S extends ExprLike<unknown> ? ExpressionValue<S, J> : { -readonly [K in keyof S]: S[K] extends SelectExpression ? ExpressionValue<S[K] extends ExprInput ? ExprFromInput<S[K]> : S[K], J> : never; };
+} ? R : S extends ExprLike<unknown> ? QueryResultValue<ExpressionValue<S, J>> : S extends readonly NamedSelectExpression[] ? { -readonly [E in S[number] as SelectKey<E>]: QueryResultValue<ExpressionValue<E, J>>; } : { -readonly [K in keyof S]: S[K] extends SelectExpression ? QueryResultValue<ExpressionValue<S[K] extends ExprInput ? ExprFromInput<S[K]> : S[K], J>> : never; };
+/**
+ * Converts top-level SQL NULL to Joist's public undefined convention.
+ *
+ * Column metadata and expressions retain `T | null` because null is an explicit SQL value used by
+ * predicates, assignments, and functions such as COALESCE. Undefined instead means an omitted input.
+ * Keeping that distinction also lets reusable queries become SQL expressions without changing domains.
+ * The conversion therefore happens only at the executed-row boundary; nested array and JSON nulls remain null.
+ */
+type QueryResultValue<V> = Exclude<V, null> | (null extends V ? undefined : never);
+/**
+ * Restores SQL NULL when a public query result is reused as an expression or mutation source.
+ *
+ * A future alternative is to retain both domains on every expression, i.e.
+ * `Expr<Sql, Src extends string = string, Result = QueryResultValue<Sql>>`. QueryRow could then use Result
+ * while predicates and reusable queries use Sql, avoiding this reverse conversion without making the
+ * common expression declaration verbose.
+ */
+type SqlExpressionValue<V> = Exclude<V, undefined> | (undefined extends V ? null : never);
 /**
  * A table-shaped query: one `Expr` per select key, each tagged with the table's name as its `Src`,
  * plus a brand carrying the row type. This is the direct analog of `Table<T>`: `Table<T>` maps physical
@@ -408,7 +454,9 @@ type QueryRow<S, J extends QueryJoins = []> = S extends {
  */
 type Subquery<R, Name extends string> = {
   readonly [subqueryBrand]: SubqueryBrand<R, Name>;
-} & { readonly [K in keyof R]: Expr<R[K], Name>; };
+} & { readonly [K in keyof R]: Expr<SqlExpressionValue<R[K]>, Name> & {
+  readonly [selectKeyBrand]: Extract<K, string>;
+}; };
 /** An entity-mode query (`select: a`): runnable, but it has no columns to reference. */
 type EntityQuery<T extends Entity> = {
   readonly [entityQueryBrand]: {
@@ -416,7 +464,7 @@ type EntityQuery<T extends Entity> = {
   };
 } & Partial<Record<MutationKey | "with" | "ctes", never>>;
 /** A scalar/list query that remains distinguishable from ordinary expressions for EXISTS. */
-type ScalarQuery<R> = Expr<R | null, never> & {
+type ScalarQuery<R> = Expr<SqlExpressionValue<R> | null, never> & {
   readonly [scalarQueryBrand]: true;
 };
 /**
@@ -447,7 +495,7 @@ type NotWidened<S> = QuerySelect extends S ? {
   select: "select was typed too generically; use `satisfies Query` instead of `: Query`";
 } : unknown;
 /** What `query()` returns, by select shape: an entity list, a scalar/list subquery, or a derived table. */
-type QueryValue<S, J extends QueryJoins, Name extends string> = S extends {
+type QueryValue<S, J extends QueryJoinList, Name extends string> = S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T extends Entity;
   };
@@ -458,7 +506,7 @@ type JoinedName<X> = X extends {
 } ? NameOf<A> : X extends {
   readonly left: infer A;
 } ? NameOf<A> : never;
-type InScope<F, J extends QueryJoins> = NameOf<F> | JoinedName<J[number]>;
+type InScope<F, J extends QueryJoinList> = NameOf<F> | JoinedName<J[number]>;
 /**
  * Asks, for every column of a POJO select: is its source key among `from` + `join` at all? If no, the
  * query reads from a table it never joined, and that select key's type becomes an error message.
@@ -474,18 +522,20 @@ type InScope<F, J extends QueryJoins> = NameOf<F> | JoinedName<J[number]>;
  * `S` to `never` when `select` is missing, and a distributive conditional over `never` would swallow the
  * whole parameter type.
  */
-type CheckScope<S, F, J extends QueryJoins> = [S] extends [never] ? unknown : [S] extends [QuerySource] ? NameOf<S> extends NameOf<F> ? unknown : {
+type CheckScope<S, F, J extends QueryJoinInput> = [S] extends [never] ? unknown : [S] extends [QuerySource] ? NameOf<S> extends NameOf<F> ? unknown : {
   select: `'${NameOf<S> & string}' is a joined source, not the from; select its columns individually`;
+} : [S] extends [readonly NamedSelectExpression[]] ? {
+  select: { [K in keyof S]: CheckExpressionScope<S[K], InScope<F, ResolvedJoins<F, J>>>; };
 } : [S] extends [Record<string, SelectExpression>] ? {
-  select: { [K in keyof S]: CheckExpressionScope<S[K], InScope<F, J>>; };
+  select: { [K in keyof S]: CheckExpressionScope<S[K], InScope<F, ResolvedJoins<F, J>>>; };
 } : unknown;
 /** Includes columns nested in inline CASE values and fallbacks in the existing scope check. */
 type CheckExpressionScope<V, Scope> = string extends ExpressionSources<V> ? unknown : [Exclude<ExpressionSources<V>, Scope>] extends [never] ? unknown : `table '${Exclude<ExpressionSources<V>, Scope> & string}' is not in from/join`;
 /** The one argument type `query()` and `em.query()` share: a `Query` POJO plus its source, name, and checks. */
-type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoins, Name extends string> = Query<S, J> & {
+type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoinInput, Name extends string> = Query<S, J> & {
   from: F;
   as?: Name;
-} & CheckScope<S, F, J> & NotWidened<S> & {
+} & CheckScope<S, F, J> & NoInfer<CheckJoinInput<F, J>> & NotWidened<S> & {
   select: CheckSelect<NoInfer<S>>;
 };
 /**
@@ -509,17 +559,17 @@ type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoins
 declare function query<const Q extends SetQuery<readonly SetOperand[]>, Name extends string = "?">(q: Q & CheckSetQuery<Q> & {
   as?: Name;
 }): Subquery<SetQueryRow<Q>, Name>;
-declare function query<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoins = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, J, Name>;
+declare function query<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name>;
 /**
- * Builds a query value only when its user-supplied `where` survives pruning.
+ * Builds a query value only when its user-supplied `where` or join-tree filters survive pruning.
  *
  * Missing or empty conditions prune the value, including nested groups and `pruneIfUndefined`.
- * Joins, HAVING, and implicit soft-delete/STI conditions do not keep the value alive.
+ * Alias-only joins, HAVING, and implicit soft-delete/STI conditions do not keep the value alive.
  *
  * I.e. `queryMaybe({ from: b, where: b.authorId.eq(enabled ? a.id : undefined), select: b.id })`
  * returns `undefined` when `enabled` is false, so an enclosing `notExists` also prunes.
  */
-declare function queryMaybe<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoins = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, J, Name> | undefined;
+declare function queryMaybe<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name> | undefined;
 /**
  * Declares a `WITH RECURSIVE` CTE from its two terms, and returns the CTE as a readable value.
  *
@@ -544,7 +594,7 @@ declare function queryMaybe<F extends QuerySource, const S extends QuerySelect =
  *
  * Unlike `query()`, the name is required, because the step term must name it.
  */
-declare function recursiveQuery<Name extends string, F extends QuerySource, const S extends QuerySelect, J extends QueryJoins>(name: Name, base: QueryArg<F, S, J, Name>, step: (self: Subquery<QueryRow<S, J>, Name>) => SetOperand, opts?: RecursiveOptions): Subquery<QueryRow<S, J>, Name>;
+declare function recursiveQuery<Name extends string, F extends QuerySource, const S extends QuerySelect, J extends QueryJoinInput>(name: Name, base: QueryArg<F, S, J, Name>, step: (self: Subquery<QueryRow<S, ResolvedJoins<F, J>>, Name>) => SetOperand, opts?: RecursiveOptions): Subquery<QueryRow<S, ResolvedJoins<F, J>>, Name>;
 /**
  * Builds a SQL expression from a tagged template.
  *
@@ -558,9 +608,9 @@ declare function recursiveQuery<Name extends string, F extends QuerySource, cons
  * // Selecting this expression keeps the join to Book b.
  * sql.number`${b.order} * ${2}`
  *
- * // Reference an unmodeled column; it is untracked at the type level.
- * sql.ref<string>(a, "ts_search")
- * sql.condition`${sql.ref(a, "ts_search")} @@ plainto_tsquery(${term})`
+ * // Reference an unmodeled column; prefer the table's own `column`, which keeps its source key.
+ * a.column<string>("ts_search")
+ * sql.condition`${a.column("ts_search")} @@ plainto_tsquery(${term})`
  * ```
  */
 declare function sql<R = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Expr<R, never>;
@@ -578,7 +628,6 @@ declare namespace sql {
   var booleanArray: (strings: TemplateStringsArray, ...values: unknown[]) => Expr<boolean[], never>;
   var booleanArrayOrNull: (strings: TemplateStringsArray, ...values: unknown[]) => Expr<boolean[] | null, never>;
   var condition: (strings: TemplateStringsArray, ...values: unknown[]) => SqlCondition;
-  var ref: <R = unknown>(source: QuerySource, column: string) => Expr<R, string>;
 }
 /**
  * Parses `arg` (a `Query` POJO or `query(...)` value) into a runnable `Plan`.
@@ -598,7 +647,7 @@ declare function isReadQueryValue(arg: unknown): boolean;
  * Compiles scalar or nonempty named expression projections, shared by SELECT and mutation RETURNING.
  * Source-shaped values need read hydration/source rules and are deliberately excluded here.
  */
-declare function projectionToSql(select: unknown, ctx: Ctx): {
+declare function projectionToSql(select: unknown, ctx: Ctx, joins?: QueryJoinList): {
   selects: SqlFragment[];
   decodeRows: Plan["decodeRows"];
   output: QueryOutput;
@@ -661,6 +710,7 @@ declare class SubqueryColumnExpr extends BaseExpr {
   private key;
   private inner;
   constructor(handle: SubqueryHandle, key: string, inner: BaseExpr);
+  get [selectKeyBrand](): string;
   toSql(ctx: ExprContext): SqlFragment;
   decode(value: unknown): unknown;
   encode(value: unknown): unknown;
@@ -790,5 +840,5 @@ declare function pruneCtes(ctes: ParsedCte[], referenced: Set<string>): ParsedCt
  */
 declare function withFragment(ctes: ParsedCte[]): SqlFragment;
 //#endregion
-export { CheckReadQuery, CheckScope, CheckSetQuery, Clauses, CompatibleValue, Ctx, EntityHydrator, EntityQuery, ExistsQuery, ExpressionOrderBy, MaybeNull, NameOf, NotWidened, OrderByDirection, OrderByKeys, ParsedCte, Plan, Query, QueryArg, QueryCondition, QueryJoin, QueryJoins, QueryOutput, QueryRow, QuerySelect, QuerySource, QueryValue, ReadQueryRow, RecursiveOptions, ScalarQuery, SelectExpression, SetOperand, SetOperation, SetQuery, SetQueryRow, Subquery, SubqueryBrand, SubqueryHandle, WithInput, WithSource, conditionToSql, entityQueryBrand, injectedConditions, isReadQueryValue, parseNestedQuery, parseUserQuery, projectionToSql, pruneCtes, query, queryMaybe, recursiveQuery, registerCtes, scalarQueryBrand, sql, subqueryBrand, withFragment };
+export { CheckReadQuery, CheckScope, CheckSetQuery, Clauses, CompatibleValue, Ctx, EntityHydrator, EntityQuery, ExistsQuery, ExpressionOrderBy, MaybeNull, NameOf, NamedSelectExpression, NotWidened, OrderByDirection, OrderByKeys, ParsedCte, Plan, Query, QueryArg, QueryCondition, QueryJoin, QueryJoinInput, QueryJoinList, QueryOutput, QueryRow, QuerySelect, QuerySource, QueryValue, ReadQueryRow, RecursiveOptions, ResolvedJoins, ScalarQuery, SelectExpression, SetOperand, SetOperation, SetQuery, SetQueryRow, SqlExpressionValue, Subquery, SubqueryBrand, SubqueryHandle, WithInput, WithSource, conditionToSql, entityQueryBrand, injectedConditions, isReadQueryValue, parseNestedQuery, parseUserQuery, projectionToSql, pruneCtes, query, queryMaybe, recursiveQuery, registerCtes, scalarQueryBrand, sql, subqueryBrand, withFragment };
 //# sourceMappingURL=query.d.mts.map

package/build/queries/sql/query.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.mts","names":[],"sources":["../../../src/queries/sql/query.ts"],"mappings":"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"}
+{"version":3,"file":"query.d.mts","names":[],"sources":["../../../src/queries/sql/query.ts"],"mappings":"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"}