qubu 0.4.0 → 0.4.2

package/dist/{types-Deo_q43Y.d.mts → types-BK1COGZe.d.mts}

@@ -4,11 +4,11 @@ interface SqlSemanticType<TName extends string = string> {
   readonly sqlType: TName;
 }
 /** Marker for extensions whose SQL domain has not been declared. */
-type SqlUnknown = SqlSemanticType<'unknown'> & {
+type SqlUnknown = SqlSemanticType<"unknown"> & {
   readonly sqlUnknown: true;
 };
 /** SQL domains accepted by text operations and the text equality group. */
-interface SqlTextLike extends SqlEqualityComparable<'text'> {
+interface SqlTextLike extends SqlEqualityComparable<"text"> {
   readonly sqlTextLike: true;
 }
 /** SQL domains accepted by numeric operations. */
@@ -20,37 +20,37 @@ interface SqlOrderable<TGroup = unknown> {
   readonly sqlOrderGroup: TGroup;
 }
 /**
- * SQL domains that can be compared for equality with the same compatibility
- * group. Dialect extensions can share a group with a portable domain.
+ * SQL domains that can be compared for equality with the same compatibility group. Dialect
+ * extensions can share a group with a portable domain.
  */
 interface SqlEqualityComparable<TGroup = unknown> {
   readonly sqlEqualityGroup: TGroup;
 }
 /** Portable text domain with text, ordering, and equality capabilities. */
-type SqlText = SqlSemanticType<'text'> & SqlTextLike & SqlOrderable<'text'> & SqlEqualityComparable<'text'>;
+type SqlText = SqlSemanticType<"text"> & SqlTextLike & SqlOrderable<"text"> & SqlEqualityComparable<"text">;
 /** Portable UUID domain; equality-capable but deliberately not text-like. */
-type SqlUuid = SqlSemanticType<'uuid'> & SqlEqualityComparable<'uuid'>;
+type SqlUuid = SqlSemanticType<"uuid"> & SqlEqualityComparable<"uuid">;
 /** Portable integer domain in the shared numeric compatibility groups. */
-type SqlInteger = SqlSemanticType<'integer'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+type SqlInteger = SqlSemanticType<"integer"> & SqlNumericLike & SqlOrderable<"numeric"> & SqlEqualityComparable<"numeric">;
 /** Portable decimal domain in the shared numeric compatibility groups. */
-type SqlDecimal = SqlSemanticType<'decimal'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+type SqlDecimal = SqlSemanticType<"decimal"> & SqlNumericLike & SqlOrderable<"numeric"> & SqlEqualityComparable<"numeric">;
 /** Portable boolean domain with equality comparison. */
-type SqlBoolean = SqlSemanticType<'boolean'> & SqlEqualityComparable<'boolean'>;
+type SqlBoolean = SqlSemanticType<"boolean"> & SqlEqualityComparable<"boolean">;
 /** Portable date domain with date-specific equality and ordering groups. */
-type SqlDate = SqlSemanticType<'date'> & SqlOrderable<'date'> & SqlEqualityComparable<'date'>;
+type SqlDate = SqlSemanticType<"date"> & SqlOrderable<"date"> & SqlEqualityComparable<"date">;
 /** Portable timestamp domain with timestamp-specific comparison groups. */
-type SqlTimestamp = SqlSemanticType<'timestamp'> & SqlOrderable<'timestamp'> & SqlEqualityComparable<'timestamp'>;
+type SqlTimestamp = SqlSemanticType<"timestamp"> & SqlOrderable<"timestamp"> & SqlEqualityComparable<"timestamp">;
 /** Portable JSON domain retaining its decoded application value type. */
-type SqlJson<TValue = unknown> = SqlSemanticType<'json'> & {
+type SqlJson<TValue = unknown> = SqlSemanticType<"json"> & {
   readonly sqlJsonValue?: TValue;
 };
 /** Portable bigint domain in the shared numeric compatibility groups. */
-type SqlBigInt = SqlSemanticType<'bigint'> & SqlNumericLike & SqlOrderable<'numeric'> & SqlEqualityComparable<'numeric'>;
+type SqlBigInt = SqlSemanticType<"bigint"> & SqlNumericLike & SqlOrderable<"numeric"> & SqlEqualityComparable<"numeric">;
 /** Portable binary domain with equality comparison. */
-type SqlBinary = SqlSemanticType<'binary'> & SqlEqualityComparable<'binary'>;
+type SqlBinary = SqlSemanticType<"binary"> & SqlEqualityComparable<"binary">;
 /** Any declared SQL semantic type, including user and dialect extensions. */
 type AnySqlType = SqlSemanticType<string>;
-type IsUnresolvedSqlType<T> = T extends SqlUnknown ? true : T extends AnySqlType ? string extends T['sqlType'] ? true : false : false;
+type IsUnresolvedSqlType<T> = T extends SqlUnknown ? true : T extends AnySqlType ? string extends T["sqlType"] ? true : false : false;
 /** Whether a declared SQL domain satisfies a semantic capability constraint. */
 type SqlTypeSatisfies<TActual, TConstraint> = true extends IsUnresolvedSqlType<TActual> ? true : TActual extends TConstraint ? true : false;
 type EqualityGroup<T> = T extends SqlEqualityComparable<infer TGroup> ? TGroup : never;
@@ -64,90 +64,90 @@ type SqlOrderCompatible<TLeft, TRight> = true extends IsUnresolvedSqlType<TLeft>
 declare const fragmentMetadata: unique symbol;
 /** Result value metadata, including nullability provenance and its SQL domain. */
 type ResultMeta<TOutput, TNullableFrom = never, TSqlType extends AnySqlType = SqlUnknown> = {
-  readonly kind: 'result';
+  readonly kind: "result";
   readonly output: TOutput;
   readonly nullableFrom: TNullableFrom;
   readonly sqlType: TSqlType;
 };
 type RequiresSourceMeta<TSource> = {
-  readonly kind: 'requires-source';
+  readonly kind: "requires-source";
   readonly source: TSource;
 };
 /** A source that must be provided by the enclosing query scope. */
 type RequiresOuterSourceMeta<TSource> = {
-  readonly kind: 'requires-outer-source';
+  readonly kind: "requires-outer-source";
   readonly source: TSource;
 };
 /** A correlated query clause that provisions sources from its enclosing scope. */
 type ProvidesOuterSourceMeta<TSource> = {
-  readonly kind: 'provides-outer-source';
+  readonly kind: "provides-outer-source";
   readonly source: TSource;
 };
 type NullableSourceMeta<TSource> = {
-  readonly kind: 'nullable-source';
+  readonly kind: "nullable-source";
   readonly source: TSource;
 };
 /** A fragment that introduces a typed relational source to FROM/JOIN. */
 type ProvidesSourceMeta<TSource, TRow = unknown> = {
-  readonly kind: 'provides-source';
+  readonly kind: "provides-source";
   readonly source: TSource;
   readonly row: TRow;
 };
 /** Dependencies read by an expression at the current query level. */
 type ExpressionMeta<TDependencies = unknown> = {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly dependencies: TDependencies;
 };
 /** Dependencies consumed inside an aggregate expression. */
 type AggregateMeta<TDependencies = unknown> = {
-  readonly kind: 'aggregate';
+  readonly kind: "aggregate";
   readonly dependencies: TDependencies;
 };
 /** Marks an expression that contains a window function. */
 type WindowMeta = {
-  readonly kind: 'window';
+  readonly kind: "window";
 };
 /** Marks an expression that contains a scalar or predicate subquery. */
 type SubqueryMeta = {
-  readonly kind: 'subquery';
+  readonly kind: "subquery";
 };
 /** Grouping keys and column dependencies made available by a GROUP BY clause. */
 type GroupingMeta<TKeys = unknown, TDependencies = unknown> = {
-  readonly kind: 'grouping';
+  readonly kind: "grouping";
   readonly keys: TKeys;
   readonly dependencies: TDependencies;
 };
-type QueryCardinality = 'many' | 'zero-or-one' | 'exactly-one';
+type QueryCardinality = "many" | "zero-or-one" | "exactly-one";
 type CardinalityMeta<TCardinality extends QueryCardinality = QueryCardinality> = {
-  readonly kind: 'cardinality';
+  readonly kind: "cardinality";
   readonly cardinality: TCardinality;
 };
 /** A fragment whose syntax must be rendered by a dialect with this capability. */
 type RequiresCapabilityMeta<TCapability extends DialectCapability = DialectCapability> = {
-  readonly kind: 'requires-capability';
+  readonly kind: "requires-capability";
   readonly capability: TCapability;
 };
 type FragmentMeta = ResultMeta<unknown, unknown, AnySqlType> | RequiresSourceMeta<unknown> | RequiresOuterSourceMeta<unknown> | ProvidesOuterSourceMeta<unknown> | NullableSourceMeta<unknown> | ProvidesSourceMeta<unknown, unknown> | ExpressionMeta | AggregateMeta | WindowMeta | SubqueryMeta | GroupingMeta | CardinalityMeta | RequiresCapabilityMeta;
 interface RenderContext {
   readonly dialect: Dialect;
   /** Whether selected fields name an application result or a SQL relation. */
-  readonly projectionMode: 'result' | 'relation';
+  readonly projectionMode: "result" | "relation";
   append(text: string): void;
   parameter(value: unknown): void;
   render(part: Fragment<any>): void;
   /** Render an embedded query with SQL-facing projection names. */
   renderRelation(part: Fragment<any>): void;
   /**
-   * Optional schema-rendering hook used to emit a bare physical column name.
-   * Ordinary query rendering leaves this undefined and retains qualification.
+   * Optional schema-rendering hook used to emit a bare physical column name. Ordinary query
+   * rendering leaves this undefined and retains qualification.
    */
   readonly renderColumnReference?: (columnName: string) => void;
 }
 type RenderFunction = (context: RenderContext) => void;
 /**
- * The smallest composable unit in qubu. Runtime rendering is deliberately
- * just a function; the metadata type carries semantic information for
- * TypeScript consumers without imposing an AST on extensions.
+ * The smallest composable unit in qubu. Runtime rendering is deliberately just a function; the
+ * metadata type carries semantic information for TypeScript consumers without imposing an AST on
+ * extensions.
  */
 interface Fragment<TMetadata = any> {
   readonly [fragmentMetadata]?: TMetadata;
@@ -156,10 +156,10 @@ interface Fragment<TMetadata = any> {
 type AnyFragment = Fragment<any>;
 type MetadataOf<T> = T extends Fragment<infer TMetadata> ? TMetadata : never;
 type WithoutResult<TMetadata> = TMetadata extends {
-  readonly kind: 'result' | 'cardinality';
+  readonly kind: "result" | "cardinality";
 } ? never : TMetadata;
 type ResultMetadata<TMetadata> = TMetadata extends {
-  readonly kind: 'result';
+  readonly kind: "result";
 } ? TMetadata : never;
 type ResultOutput<TMetadata> = TMetadata extends {
   readonly output: infer TOutput;
@@ -171,43 +171,43 @@ type ResultSqlType<TMetadata> = TMetadata extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown;
 type RequiredSource<TMetadata> = TMetadata extends {
-  readonly kind: 'requires-source';
+  readonly kind: "requires-source";
   readonly source: infer TSource;
 } ? TSource : never;
 type RequiredOuterSource<TMetadata> = TMetadata extends {
-  readonly kind: 'requires-outer-source';
+  readonly kind: "requires-outer-source";
   readonly source: infer TSource;
 } ? TSource : never;
 type ProvidedOuterSource<TMetadata> = TMetadata extends {
-  readonly kind: 'provides-outer-source';
+  readonly kind: "provides-outer-source";
   readonly source: infer TSource;
 } ? TSource : never;
 type NullableSource<TMetadata> = TMetadata extends {
-  readonly kind: 'nullable-source';
+  readonly kind: "nullable-source";
   readonly source: infer TSource;
 } ? TSource : never;
 type ExpressionDependencies<TMetadata> = TMetadata extends {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never;
 type AggregateDependencies<TMetadata> = TMetadata extends {
-  readonly kind: 'aggregate';
+  readonly kind: "aggregate";
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never;
 type GroupingKeys<TMetadata> = TMetadata extends {
-  readonly kind: 'grouping';
+  readonly kind: "grouping";
   readonly keys: infer TKeys;
 } ? TKeys : never;
 type GroupingDependencies<TMetadata> = TMetadata extends {
-  readonly kind: 'grouping';
+  readonly kind: "grouping";
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never;
 type Cardinality<TMetadata> = TMetadata extends {
-  readonly kind: 'cardinality';
+  readonly kind: "cardinality";
   readonly cardinality: infer TCardinality;
 } ? TCardinality : never;
 type RequiredCapabilities<TMetadata> = TMetadata extends {
-  readonly kind: 'requires-capability';
+  readonly kind: "requires-capability";
   readonly capability: infer TCapability extends DialectCapability;
 } ? TCapability : never;
 type InheritedMetadataOf<TMetadata> = WithoutResult<TMetadata>;
@@ -219,7 +219,7 @@ type RequiresOf<T> = RequiredSource<MetadataOf<T>>;
 type RequiresOuterOf<T> = RequiredOuterSource<MetadataOf<T>>;
 type ProvidesOuterOf<T> = ProvidedOuterSource<MetadataOf<T>>;
 type RequiresOuterMetadataOf<T> = Extract<MetadataOf<T>, {
-  readonly kind: 'requires-outer-source';
+  readonly kind: "requires-outer-source";
 }>;
 type NullabilityOf<T> = ResultNullableFrom<ResultMetadata<MetadataOf<T>>>;
 type NullableSourcesOf<T> = NullableSource<MetadataOf<T>>;
@@ -230,13 +230,13 @@ type VisibleDependenciesOf<T> = Exclude<DependenciesOf<T>, AggregateDependencies
 type GroupingKeysOf<T> = GroupingKeys<MetadataOf<T>>;
 type GroupingDependenciesOf<T> = GroupingDependencies<MetadataOf<T>>;
 type HasAggregate<T> = [Extract<MetadataOf<T>, {
-  readonly kind: 'aggregate';
+  readonly kind: "aggregate";
 }>] extends [never] ? false : true;
 type HasWindow<T> = [Extract<MetadataOf<T>, {
-  readonly kind: 'window';
+  readonly kind: "window";
 }>] extends [never] ? false : true;
 type HasSubquery<T> = [Extract<MetadataOf<T>, {
-  readonly kind: 'subquery';
+  readonly kind: "subquery";
 }>] extends [never] ? false : true;
 type CardinalityOf<T> = Cardinality<MetadataOf<T>>;
 type CapabilitiesOf<T> = RequiredCapabilities<MetadataOf<T>>;
@@ -248,7 +248,7 @@ declare function isFragment(value: unknown): value is AnyFragment;
 //#endregion
 //#region src/result.d.ts
 /** Portable result domains that can require driver-specific normalization. */
-type DecodableResultType = 'boolean' | 'date' | 'timestamp' | 'json';
+type DecodableResultType = "boolean" | "date" | "timestamp" | "json";
 /** Context supplied while decoding one projected field. */
 interface ResultDecodeContext {
   readonly dialect: Dialect;
@@ -295,7 +295,7 @@ declare class ResultDecodingError extends TypeError {
 }
 //#endregion
 //#region src/expressions/types.d.ts
-type ExpressionKind = 'value' | 'column' | 'function' | 'operator' | 'sql' | 'subquery' | 'unsafe';
+type ExpressionKind = "value" | "column" | "function" | "operator" | "sql" | "subquery" | "unsafe";
 /** Runtime/type-level proof that an expression is safe to use in schema SQL. */
 declare const schemaExpressionBrand: unique symbol;
 interface SchemaExpressionBrand {
@@ -304,12 +304,11 @@ interface SchemaExpressionBrand {
 interface Expression<TMetadata = any, TKind extends ExpressionKind = ExpressionKind> extends Fragment<TMetadata>, ResultValueCarrier {
   readonly expressionKind: TKind;
   /** Internal runtime marker for query constructs rejected by schema SQL. */
-  readonly expressionCategory?: 'aggregate' | 'window' | 'subquery';
+  readonly expressionCategory?: "aggregate" | "window" | "subquery";
 }
 /**
- * An expression whose renderer is deterministic and may be used by schema
- * metadata. Query extensions remain ordinary {@link Expression} values until
- * they explicitly opt into this contract.
+ * An expression whose renderer is deterministic and may be used by schema metadata. Query
+ * extensions remain ordinary {@link Expression} values until they explicitly opt into this contract.
  */
 type SchemaExpression<TMetadata = any, TKind extends ExpressionKind = ExpressionKind> = Expression<TMetadata, TKind> & SchemaExpressionBrand;
 type AnyExpression = Expression<any, any>;
@@ -320,7 +319,7 @@ type ExpressionNullability<T> = NullabilityOf<T>;
 /** Extract the SQL semantic domain produced by an expression. */
 type ExpressionSqlType<T> = SqlTypeOf<T>;
 /** Add a concrete dialect requirement without dropping expression metadata. */
-declare function withDialectCapability<const TCapability extends DialectCapability, TExpression extends AnyExpression>(expression: TExpression, capability: TCapability): TExpression extends SchemaExpression<any, any> ? SchemaExpression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression['expressionKind']> : Expression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression['expressionKind']>;
+declare function withDialectCapability<const TCapability extends DialectCapability, TExpression extends AnyExpression>(expression: TExpression, capability: TCapability): TExpression extends SchemaExpression<any, any> ? SchemaExpression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression["expressionKind"]> : Expression<MetadataOf<TExpression> | RequiresCapabilityMeta<TCapability>, TExpression["expressionKind"]>;
 /** An expression whose result is known to be assignable to `TOutput`. */
 type ExpressionWithOutput<TOutput, TKind extends ExpressionKind = ExpressionKind> = Expression<ResultMeta<TOutput, unknown, AnySqlType> | RequiresSourceMeta<unknown> | NullableSourceMeta<unknown> | ExpressionMeta<unknown> | AggregateMeta<unknown> | RequiresCapabilityMeta | WindowMeta | SubqueryMeta, TKind>;
 /** Sparse type-level configuration for a result-producing expression. */
@@ -332,31 +331,31 @@ interface ResultExpressionConfig {
   readonly sqlType?: AnySqlType;
 }
 type ResultConfigValue<TConfig, TKey extends PropertyKey, TFallback> = TKey extends keyof TConfig ? TConfig[TKey] : TFallback;
-type ResultConfigOutput<TConfig> = ResultConfigValue<TConfig, 'output', unknown>;
-type ResultConfigChildren<TConfig> = ResultConfigValue<TConfig, 'children', never>;
-type ResultConfigKind<TConfig> = Extract<ResultConfigValue<TConfig, 'kind', ExpressionKind>, ExpressionKind>;
-type ResultConfigNullableFrom<TConfig> = ResultConfigValue<TConfig, 'nullableFrom', NullabilityOf<ResultConfigChildren<TConfig>>>;
-type ResultConfigSqlType<TConfig> = Extract<ResultConfigValue<TConfig, 'sqlType', SqlUnknown>, AnySqlType>;
+type ResultConfigOutput<TConfig> = ResultConfigValue<TConfig, "output", unknown>;
+type ResultConfigChildren<TConfig> = ResultConfigValue<TConfig, "children", never>;
+type ResultConfigKind<TConfig> = Extract<ResultConfigValue<TConfig, "kind", ExpressionKind>, ExpressionKind>;
+type ResultConfigNullableFrom<TConfig> = ResultConfigValue<TConfig, "nullableFrom", NullabilityOf<ResultConfigChildren<TConfig>>>;
+type ResultConfigSqlType<TConfig> = Extract<ResultConfigValue<TConfig, "sqlType", SqlUnknown>, AnySqlType>;
 /** Build an expression result while inheriting non-result metadata from children. */
 type ResultExpression<TConfig extends ResultExpressionConfig = {}> = SchemaExpression<ResultMeta<ResultConfigOutput<TConfig>, ResultConfigNullableFrom<TConfig>, ResultConfigSqlType<TConfig>> | ExpressionMeta<DependenciesOf<ResultConfigChildren<TConfig>>> | InheritedMetadata<ResultConfigChildren<TConfig>>, ResultConfigKind<TConfig>>;
 /** Build an aggregate result while recording which dependencies it consumes. */
 type AggregateResultExpression<TConfig extends ResultExpressionConfig = {}> = Expression<ResultMeta<ResultConfigOutput<TConfig>, ResultConfigNullableFrom<TConfig>, ResultConfigSqlType<TConfig>> | ExpressionMeta<DependenciesOf<ResultConfigChildren<TConfig>>> | AggregateMeta<DependenciesOf<ResultConfigChildren<TConfig>>> | InheritedMetadata<ResultConfigChildren<TConfig>>, ResultConfigKind<TConfig>>;
 /** A result expression that contains a query boundary. */
-type SubqueryResultExpression<TConfig extends Omit<ResultExpressionConfig, 'kind'> = {}> = Expression<ResultMeta<ResultConfigOutput<TConfig>, ResultConfigNullableFrom<TConfig>, ResultConfigSqlType<TConfig>> | ExpressionMeta<DependenciesOf<ResultConfigChildren<TConfig>>> | InheritedMetadata<ResultConfigChildren<TConfig>> | SubqueryMeta, 'subquery'>;
-declare function makeExpression<TMetadata = never, TKind extends ExpressionKind = ExpressionKind>(expressionKind: TKind, render: (context: RenderContext) => void, expressionCategory?: 'aggregate' | 'window' | 'subquery', result?: ResultValueMetadata): Expression<TMetadata, TKind>;
+type SubqueryResultExpression<TConfig extends Omit<ResultExpressionConfig, "kind"> = {}> = Expression<ResultMeta<ResultConfigOutput<TConfig>, ResultConfigNullableFrom<TConfig>, ResultConfigSqlType<TConfig>> | ExpressionMeta<DependenciesOf<ResultConfigChildren<TConfig>>> | InheritedMetadata<ResultConfigChildren<TConfig>> | SubqueryMeta, "subquery">;
+declare function makeExpression<TMetadata = never, TKind extends ExpressionKind = ExpressionKind>(expressionKind: TKind, render: (context: RenderContext) => void, expressionCategory?: "aggregate" | "window" | "subquery", result?: ResultValueMetadata): Expression<TMetadata, TKind>;
 /** Mark a query-only expression category without changing its SQL renderer. */
-declare function markExpressionCategory<TMetadata, TKind extends ExpressionKind>(expression: Expression<TMetadata, TKind>, category: 'aggregate' | 'window' | 'subquery'): Expression<TMetadata, TKind>;
+declare function markExpressionCategory<TMetadata, TKind extends ExpressionKind>(expression: Expression<TMetadata, TKind>, category: "aggregate" | "window" | "subquery"): Expression<TMetadata, TKind>;
 declare function isExpression(value: unknown): value is AnyExpression;
 //#endregion
 //#region src/expressions/column.d.ts
-interface ColumnReference<TFieldName extends string = string, TMetadata = never> extends SchemaExpression<TMetadata, 'column'> {
+interface ColumnReference<TFieldName extends string = string, TMetadata = never> extends SchemaExpression<TMetadata, "column"> {
   /** Application-facing key used by typed rows and dependency metadata. */
   readonly fieldName: TFieldName;
   /** Physical SQL identifier rendered for this column. */
   readonly columnName: string;
 }
 type ColumnDependency<TSource, TName extends string> = {
-  readonly kind: 'column';
+  readonly kind: "column";
   readonly source: TSource;
   readonly name: TName;
 };
@@ -364,9 +363,254 @@ type ColumnGroupingDependencies<T> = T extends ColumnReference<any, any> ? Depen
 /** Turn an expression into a fragment that renders it without changing it. */
 declare function expressionFragment<TExpression extends Expression>(expression: TExpression): Fragment<MetadataOf<TExpression>>;
 //#endregion
+//#region src/query/errors.d.ts
+/** Stable diagnostics shared by type-level and runtime query validation. */
+type QueryValidationErrorCode = "invalid-selection" | "duplicate-clause" | "invalid-mutation" | "unsafe-mutation" | "invalid-update" | "invalid-insert" | "invalid-comparison" | "invalid-boolean-expression" | "invalid-pagination" | "invalid-row-lock" | "invalid-json-path" | "missing-source" | "invalid-grouping" | "incompatible-sql-domain" | "incompatible-sql-equality" | "incompatible-sql-order" | "incompatible-set-domain" | "invalid-subquery" | "invalid-omission" | "invalid-stream-query" | "invalid-explain-query" | "invalid-explain-options" | "unsupported-explain-option" | "unsupported-explain-dialect" | "missing-dialect-capability";
+interface QueryValidationIssue {
+  readonly code: QueryValidationErrorCode;
+  readonly context: string;
+  readonly path: readonly (string | number)[];
+  readonly message: string;
+  readonly hint: string;
+}
+/**
+ * A type-level query failure that names the failing rule and the repair path. The legacy detail
+ * field is optional so each validator can retain the useful source or clause type in the compiler
+ * diagnostic.
+ */
+type QueryTypeValidation<TCode extends QueryValidationErrorCode, TContext extends string, THint extends string, TDetail = never> = {
+  readonly __qubu_error_code__: TCode;
+  readonly __qubu_error_context__: TContext;
+  readonly __qubu_error_hint__: THint;
+} & ([TDetail] extends [never] ? unknown : {
+  readonly __qubu_error_detail__: TDetail;
+});
+/** Raised when a query cannot satisfy Qubu's runtime authoring rules. */
+declare class QueryValidationError extends TypeError {
+  readonly name = "QueryValidationError";
+  readonly code: QueryValidationErrorCode;
+  readonly context: string;
+  readonly path: readonly (string | number)[];
+  readonly hint: string;
+  readonly issue: QueryValidationIssue;
+  constructor(issue: QueryValidationIssue);
+}
+//#endregion
+//#region src/core/render.d.ts
+type DefaultDialectCapability = "json";
+interface RenderedQuery {
+  readonly text: string;
+  readonly parameters: readonly unknown[];
+}
+interface RenderOptions<TCapabilities extends DialectCapability = DialectCapability> {
+  readonly dialect?: Dialect<TCapabilities>;
+}
+type IsAny$1<T> = 0 extends 1 & T ? true : false;
+type MissingCapabilities<TQuery, TCapabilities extends DialectCapability> = IsAny$1<CapabilitiesOf<TQuery>> extends true ? never : Exclude<CapabilitiesOf<TQuery>, TCapabilities>;
+type RenderCapabilityValidation<TQuery, TCapabilities extends DialectCapability> = [MissingCapabilities<TQuery, TCapabilities>] extends [never] ? unknown : QueryTypeValidation<"missing-dialect-capability", "render.dialect", "Provide a dialect that supports every capability required by the query.", MissingCapabilities<TQuery, TCapabilities>>;
+declare function render<TQuery extends AnyFragment>(query: TQuery & RenderCapabilityValidation<TQuery, DefaultDialectCapability>): RenderedQuery;
+declare function render<TQuery extends AnyFragment, TCapabilities extends DialectCapability>(query: TQuery & RenderCapabilityValidation<TQuery, TCapabilities>, options: RenderOptions<TCapabilities> | Dialect<TCapabilities>): RenderedQuery;
+//#endregion
+//#region src/execution.d.ts
+type StreamableQuery<TRow extends object = Record<string, unknown>> = QueryWithRow<TRow> & {
+  readonly queryKind: "select" | "set";
+};
+/** Rendering policy and cancellation input accepted by query execution. */
+interface ExecutionOptions extends RenderOptions {
+  /** Passed to the application adapter for drivers that support cancellation. */
+  readonly signal?: AbortSignal;
+}
+/** Rendering, EXPLAIN, and cancellation options for plan requests. */
+interface ExplainOptions extends RenderOptions, ExplainRenderOptions {
+  /** Passed to the application adapter for drivers that support cancellation. */
+  readonly signal?: AbortSignal;
+}
+/** EXPLAIN options accepted for SELECT and set-operation queries. */
+type ExplainReadOptions = ExplainOptions;
+/** EXPLAIN options for mutations, which never run with analysis enabled. */
+type ExplainMutationOptions = Omit<ExplainOptions, "analyze"> & {
+  readonly analyze?: never;
+};
+/** Select read-only or plan-only EXPLAIN options from the query kind. */
+type ExplainOptionsFor<TQuery extends AnyQuery> = TQuery["queryKind"] extends "select" | "set" ? ExplainReadOptions : ExplainMutationOptions;
+/** Controls the lifecycle of one adapter-owned transaction. */
+interface TransactionOptions {
+  /** Passed to the adapter for transaction begin, commit, and rollback. */
+  readonly signal?: AbortSignal;
+}
+/** One rendered statement and the controls passed to an application adapter. */
+interface ExecutionRequest {
+  /** SQL text and raw application parameters produced by Qubu's renderer. */
+  readonly statement: RenderedQuery;
+  /** The source query kind, available without parsing rendered SQL. */
+  readonly queryKind: QueryKind;
+  /** Named logical fields used by Qubu after the adapter returns raw rows. */
+  readonly resultShape: ResultShape;
+  /** Present when the caller supplied an abort signal to {@link execute} or {@link stream}. */
+  readonly signal?: AbortSignal;
+}
+/** One rendered EXPLAIN statement and the controls passed to an adapter. */
+interface ExplainRequest extends ExecutionRequest {}
+/**
+ * Driver-neutral rows and optional mutation facts returned by an adapter.
+ *
+ * Adapters normalize driver result fields into this shape. They should omit a mutation fact when
+ * the driver cannot report it accurately.
+ */
+interface ExecutionResult<TRow extends object = Record<string, unknown>> {
+  /** Decoded result rows. Mutations without `RETURNING` use an empty array. */
+  readonly rows: readonly TRow[];
+  /** Rows inserted, updated, or deleted when the driver reports that count. */
+  readonly affectedRows?: number | bigint;
+  /** Rows whose stored values changed when distinct from affected rows. */
+  readonly changedRows?: number | bigint;
+  /** An insert identifier reported by the driver, including generated IDs. */
+  readonly insertId?: string | number | bigint;
+}
+/** Driver-normalized rows and mutation facts returned to Qubu by an adapter. */
+interface AdapterExecutionResult {
+  /** Object rows keyed by the query's rendered result aliases. */
+  readonly rows: readonly Readonly<Record<string, unknown>>[];
+  readonly affectedRows?: number | bigint;
+  readonly changedRows?: number | bigint;
+  readonly insertId?: string | number | bigint;
+}
+/** Adapter-decoded vendor plan rows returned by an EXPLAIN request. */
+interface ExplainResult<TPlanRow extends object = Record<string, unknown>> {
+  /** Opaque plan rows in the shape selected by the application adapter. */
+  readonly rows: readonly TPlanRow[];
+}
+/**
+ * The driver-facing boundary. `request.statement.parameters` contains raw application values in
+ * placeholder order; the adapter binds and encodes them for its driver. Connection pooling,
+ * transactions, retries, and proprietary driver-row normalization remain adapter concerns. Qubu
+ * applies the adapter's registered logical result decoders afterward.
+ */
+interface QueryAdapter {
+  /** Default rendering policy for queries sent through this adapter. */
+  readonly dialect: Dialect;
+  /** Driver-specific conversions for portable logical result domains. */
+  readonly decoders?: ResultDecoders;
+  /** Execute one request and normalize the driver's result fields. */
+  execute(request: ExecutionRequest): Promise<AdapterExecutionResult>;
+}
+/**
+ * An opt-in adapter capability for typed, adapter-decoded EXPLAIN results.
+ *
+ * Qubu renders and validates the statement. The adapter binds parameters, executes the plan
+ * request, owns cancellation and connection lifecycle, and decodes vendor-specific plan rows
+ * without a cross-dialect Qubu plan tree.
+ */
+interface ExplainableQueryAdapter<TPlanRow extends object = Record<string, unknown>> extends QueryAdapter {
+  explain(request: ExplainRequest): Promise<ExplainResult<TPlanRow>>;
+}
+/** Extract the plan-row type owned by an explainable adapter. */
+type ExplainPlanRow<TAdapter extends ExplainableQueryAdapter> = TAdapter extends ExplainableQueryAdapter<infer TPlanRow> ? TPlanRow : never;
+/**
+ * An opt-in adapter capability for streaming rows from read queries.
+ *
+ * The adapter owns the returned iterator and every resource behind it. The iterator must release
+ * those resources when it completes, is closed early, fails, or observes an aborted request
+ * signal.
+ */
+interface StreamingQueryAdapter extends QueryAdapter {
+  /** Return an adapter-owned object-row stream for one SELECT or set query. */
+  stream(request: ExecutionRequest): AsyncIterable<Readonly<Record<string, unknown>>>;
+}
+type QueryExecutor = QueryAdapter;
+/**
+ * An adapter that can pin one driver connection for a callback transaction. The callback receives
+ * an adapter scoped to that transaction. Qubu does not issue transaction SQL or manage the driver's
+ * connection lifecycle.
+ */
+interface TransactionalQueryAdapter<TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QueryAdapter {
+  transaction<T>(callback: (adapter: TTransactionAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+type TransactionAdapterOf<TAdapter extends TransactionalQueryAdapter> = TAdapter extends TransactionalQueryAdapter<infer TTransactionAdapter> ? TTransactionAdapter : never;
+/** A transaction-capable streaming adapter whose scoped client can stream. */
+type StreamingTransactionalQueryAdapter = StreamingQueryAdapter & TransactionalQueryAdapter<StreamingQueryAdapter>;
+/** A query client with one application-owned adapter bound to every call. */
+interface QubuClient<TAdapter extends QueryAdapter = QueryAdapter> {
+  /** The adapter supplied to {@link qubu}. */
+  readonly adapter: TAdapter;
+  /** Execute a query and keep the adapter's structured mutation facts. */
+  execute<TRow extends object>(query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+  /** Execute a query and return only its decoded rows. */
+  rows<TRow extends object>(query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<readonly TRow[]>;
+}
+/** A bound client whose adapter also decodes vendor-specific EXPLAIN rows. */
+interface QubuExplainableClient<TAdapter extends ExplainableQueryAdapter = ExplainableQueryAdapter> extends QubuClient<TAdapter> {
+  /** Explain a query without executing it and return adapter-owned plan rows. */
+  explain<TQuery extends AnyQuery>(query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+}
+/** A bound client whose adapter also supports typed read-query streams. */
+interface QubuStreamingClient<TAdapter extends StreamingQueryAdapter = StreamingQueryAdapter> extends QubuClient<TAdapter> {
+  /** Stream decoded rows without materializing the complete result. */
+  stream<TRow extends object>(query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
+}
+/** A bound client that supports both streaming and typed EXPLAIN plans. */
+interface QubuStreamingExplainableClient<TAdapter extends StreamingQueryAdapter & ExplainableQueryAdapter = StreamingQueryAdapter & ExplainableQueryAdapter> extends QubuStreamingClient<TAdapter>, QubuExplainableClient<TAdapter> {}
+type QubuClientFor<TAdapter extends QueryAdapter> = TAdapter extends StreamingQueryAdapter ? TAdapter extends ExplainableQueryAdapter ? QubuStreamingExplainableClient<TAdapter> : QubuStreamingClient<TAdapter> : TAdapter extends ExplainableQueryAdapter ? QubuExplainableClient<TAdapter> : QubuClient<TAdapter>;
+/** The client available inside a transaction callback. */
+type QubuTransaction = QubuClient<QueryAdapter>;
+/** The streaming client available inside a streaming transaction callback. */
+type QubuStreamingTransaction = QubuStreamingClient<StreamingQueryAdapter>;
+/** A bound client whose adapter supports transaction-scoped execution. */
+interface QubuTransactionalClient<TAdapter extends TransactionalQueryAdapter = TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QubuClient<TAdapter> {
+  /** Run several queries on one adapter-owned transaction. */
+  transaction<T>(callback: (transaction: QubuClientFor<TTransactionAdapter>) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/** A bound EXPLAIN client with an adapter-owned transaction callback. */
+type QubuExplainableTransactionalClient<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter = ExplainableQueryAdapter & TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> = QubuExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, TTransactionAdapter>;
+/** A bound streaming and EXPLAIN client with an adapter-owned transaction. */
+type QubuExplainableStreamingTransactionalClient<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter = ExplainableQueryAdapter & StreamingTransactionalQueryAdapter> = QubuStreamingExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, StreamingQueryAdapter>;
+/** A bound streaming client whose transaction callback can also stream. */
+interface QubuStreamingTransactionalClient<TAdapter extends StreamingTransactionalQueryAdapter = StreamingTransactionalQueryAdapter> extends QubuStreamingClient<TAdapter> {
+  /** Run a callback whose streams must be consumed or closed before it resolves. */
+  transaction<T>(callback: (transaction: QubuStreamingTransaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
+}
+/** Bind an application-owned adapter once for repeated query execution. */
+declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableStreamingTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter): QubuExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuStreamingTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter> & QubuStreamingClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
+declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingClient<TAdapter>;
+declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter): QubuClient<TAdapter>;
+interface DriverValueEncoder<TDriverValue = unknown> {
+  /** Convert one Qubu parameter into the driver's bindable representation. */
+  encode(value: unknown): TDriverValue;
+}
+/**
+ * Render a typed query, pass it to an application adapter, and return the adapter's structured
+ * result unchanged.
+ *
+ * Driver errors are not caught or translated.
+ */
+declare function execute<TRow extends object>(query: QueryWithRow<TRow>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+declare function execute<TRow extends object>(adapter: QueryAdapter, query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
+/** Execute a query and return its decoded rows without mutation facts. */
+declare function executeRows<TRow extends object>(query: QueryWithRow<TRow>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<readonly TRow[]>;
+declare function executeRows<TRow extends object>(adapter: QueryAdapter, query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<readonly TRow[]>;
+/**
+ * Render a query as a dialect-specific EXPLAIN request and return the adapter-decoded vendor plan
+ * rows. EXPLAIN never calls QueryAdapter.execute.
+ */
+declare function explain<TQuery extends AnyQuery, TAdapter extends ExplainableQueryAdapter>(query: TQuery, adapter: TAdapter, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+declare function explain<TQuery extends AnyQuery, TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter, query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
+/**
+ * Render a SELECT or set-operation query and return the adapter-owned row stream. Mutations,
+ * including mutations with RETURNING, must use execute().
+ */
+declare function stream<TRow extends object>(query: StreamableQuery<TRow>, adapter: StreamingQueryAdapter, options?: ExecutionOptions): AsyncIterable<TRow>;
+declare function stream<TRow extends object>(adapter: StreamingQueryAdapter, query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
+//#endregion
 //#region src/schema/metadata.d.ts
 /** Dialect identities with first-party schema metadata adapters. */
-type SchemaDialectName = 'postgresql' | 'sqlite' | 'mysql';
+type SchemaDialectName = "postgresql" | "sqlite" | "mysql";
 /** A dialect-owned extension attached to serializable schema metadata. */
 interface SchemaDialectExtension<TDialect extends string = string> {
   readonly dialect: TDialect;
@@ -385,7 +629,7 @@ interface SchemaObjectIdentity {
 }
 /** Structured diagnostics produced while resolving relational metadata. */
 interface SchemaMetadataDiagnostic {
-  readonly code: 'invalid-physical-name' | 'duplicate-physical-name' | 'dialect-mismatch' | 'unsupported-dialect-option';
+  readonly code: "invalid-physical-name" | "duplicate-physical-name" | "dialect-mismatch" | "unsupported-dialect-option";
   readonly message: string;
   readonly path: readonly (string | number)[];
   readonly relatedPaths?: readonly (readonly (string | number)[])[];
@@ -405,20 +649,19 @@ declare function freezeSchemaMetadata<T>(value: T): T;
 /** Check the portable identifier subset used for generated metadata names. */
 declare function isValidSchemaObjectName(name: string): boolean;
 /**
- * Attach a record key and resolved physical name without changing the
- * enumerable shape of legacy constraint/index values. The properties are
- * still ordinary read-only runtime metadata and are available to snapshot
- * traversals.
+ * Attach a record key and resolved physical name without changing the enumerable shape of legacy
+ * constraint/index values. The properties are still ordinary read-only runtime metadata and are
+ * available to snapshot traversals.
  */
 declare function materializeSchemaObjectIdentity<TValue extends object>(value: TValue, id: string, physicalName?: string): TValue & SchemaObjectIdentity;
 type NamedMetadataValue = object & {
   readonly physicalName?: string;
 };
 /**
- * Resolve and validate names for one metadata record. The caller decides
- * whether constraint and index names share a database namespace.
+ * Resolve and validate names for one metadata record. The caller decides whether constraint and
+ * index names share a database namespace.
  */
-declare function materializeSchemaObjectRecord<TValue extends NamedMetadataValue>(record: Readonly<Record<string, TValue>>, kind: 'constraint' | 'index'): Readonly<Record<string, TValue & SchemaObjectIdentity>>;
+declare function materializeSchemaObjectRecord<TValue extends NamedMetadataValue>(record: Readonly<Record<string, TValue>>, kind: "constraint" | "index"): Readonly<Record<string, TValue & SchemaObjectIdentity>>;
 /** Return a diagnostic when a dialect extension is used by another adapter. */
 declare function dialectMismatchDiagnostic(extension: SchemaDialectExtension, dialect: string, path: readonly (string | number)[]): SchemaMetadataDiagnostic | undefined;
 /** Throw a structured error for one or more dialect capability findings. */
@@ -430,70 +673,70 @@ type SchemaLiteralValue = null | boolean | string | number | bigint;
 /**
  * Public input accepted by a column's `default` option.
  *
- * Primitive values are always literals. Branded schema expressions are
- * rendered as SQL expressions, and an external descriptor records a default
- * whose definition belongs to another schema authority.
+ * Primitive values are always literals. Branded schema expressions are rendered as SQL expressions,
+ * and an external descriptor records a default whose definition belongs to another schema
+ * authority.
  */
 type ColumnDefaultInput = SchemaLiteralValue | AnySchemaExpression | ExternalDefaultDescriptor;
 /** A canonical, dialect-neutral literal node retained by default metadata. */
 type CanonicalLiteral = {
-  readonly kind: 'null';
+  readonly kind: "null";
 } | {
-  readonly kind: 'boolean';
+  readonly kind: "boolean";
   readonly value: boolean;
 } | {
-  readonly kind: 'string';
+  readonly kind: "string";
   readonly value: string;
 } | {
-  readonly kind: 'number';
+  readonly kind: "number";
   readonly value: string;
 } | {
-  readonly kind: 'bigint';
+  readonly kind: "bigint";
   readonly value: string;
 };
 /** A default represented by a canonical literal node. */
 interface LiteralDefaultDescriptor<TLiteral extends CanonicalLiteral = CanonicalLiteral> {
-  readonly kind: 'literal';
+  readonly kind: "literal";
   readonly value: TLiteral;
 }
 /** A default whose SQL is retained as a deterministic schema expression. */
 interface ExpressionDefaultDescriptor<TExpression extends AnySchemaExpression = AnySchemaExpression> {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expression: TExpression;
 }
 /** A default supplied by the database or another external schema authority. */
 interface ExternalDefaultDescriptor {
-  readonly kind: 'external';
+  readonly kind: "external";
 }
 /** Complete default metadata carried by a column definition. */
 type ColumnDefault = LiteralDefaultDescriptor | ExpressionDefaultDescriptor | ExternalDefaultDescriptor;
 /** Alias used by snapshot and schema tooling consumers. */
 type DefaultDescriptor = ColumnDefault;
 /** Storage mode for a generated-column expression. */
-type GeneratedColumnMode = 'stored' | 'virtual';
+type GeneratedColumnMode = "stored" | "virtual";
 /** A generated column with an expression that can be rendered later. */
 interface ExpressionGeneratedColumnDescriptor<TExpression extends AnySchemaExpression = AnySchemaExpression> {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expression: TExpression;
   readonly mode: GeneratedColumnMode;
 }
 /** A generated-column behavior known to exist but owned externally. */
 interface ExternalGeneratedColumnDescriptor {
-  readonly kind: 'external';
+  readonly kind: "external";
 }
 /** Complete generated-column metadata, separate from identity metadata. */
 type GeneratedColumnDescriptor = ExpressionGeneratedColumnDescriptor | ExternalGeneratedColumnDescriptor;
 /** Alias used by snapshot and schema tooling consumers. */
 type GeneratedDescriptor = GeneratedColumnDescriptor;
 /** Identity generation policy. Identity is not an ordinary SQL expression. */
-type IdentityGeneration = 'always' | 'by-default';
+type IdentityGeneration = "always" | "by-default";
 /** SQLite's opt-in AUTOINCREMENT behavior for an INTEGER rowid alias. */
-interface SqliteIdentityExtension extends SchemaDialectExtension<'sqlite'> {
+interface SqliteIdentityExtension extends SchemaDialectExtension<"sqlite"> {
   /** Preserve deleted rowids instead of allowing SQLite to reuse them. */
   readonly autoIncrement?: boolean;
 }
 /** MySQL's column-level AUTO_INCREMENT identity detail. */
-interface MysqlIdentityExtension extends SchemaDialectExtension<'mysql'> {
+interface MysqlIdentityExtension extends SchemaDialectExtension<"mysql"> {
   /** Emit MySQL's AUTO_INCREMENT behavior for this identity column. */
   readonly autoIncrement?: boolean;
 }
@@ -501,13 +744,13 @@ interface MysqlIdentityExtension extends SchemaDialectExtension<'mysql'> {
 type IdentityDialectExtension = SqliteIdentityExtension | MysqlIdentityExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
 /** Complete identity metadata for a database-generated column value. */
 interface IdentityDescriptor {
-  readonly kind: 'identity';
+  readonly kind: "identity";
   readonly generation: IdentityGeneration;
   /** Optional dialect-owned identity semantics such as SQLite AUTOINCREMENT. */
   readonly dialect?: IdentityDialectExtension;
 }
 /** Structured failures raised while resolving column behavior metadata. */
-type ColumnBehaviorErrorCode = 'invalid-default' | 'invalid-generated-column' | 'invalid-identity' | 'invalid-on-update' | 'default-flag-conflict' | 'generated-flag-conflict' | 'default-generated-conflict' | 'identity-generated-conflict';
+type ColumnBehaviorErrorCode = "invalid-default" | "invalid-generated-column" | "invalid-identity" | "invalid-on-update" | "default-flag-conflict" | "generated-flag-conflict" | "default-generated-conflict" | "identity-generated-conflict";
 /** A column behavior error with a stable code and optional property path. */
 declare class ColumnBehaviorError extends TypeError {
   readonly code: ColumnBehaviorErrorCode;
@@ -549,16 +792,16 @@ declare function resolveColumnBehavior(options: {
 //#endregion
 //#region src/schema/column.d.ts
 /** Portable physical storage spellings understood by every schema dialect. */
-type PortableStorageType = 'integer' | 'numeric' | 'text' | 'boolean' | 'date' | 'timestamp' | 'uuid' | 'json' | 'bigint' | 'binary';
+type PortableStorageType = "integer" | "numeric" | "text" | "boolean" | "date" | "timestamp" | "uuid" | "json" | "bigint" | "binary";
 /** A dialect-neutral physical storage descriptor. */
 interface PortableColumnStorage<TType extends PortableStorageType = PortableStorageType> {
-  readonly kind: 'portable';
+  readonly kind: "portable";
   /** Stable physical storage category, independent of the SQL domain. */
   readonly type: TType;
 }
 /** A physical storage declaration owned by one SQL dialect. */
 interface NativeColumnStorage<TDialect extends string = string, TDeclaration extends string = string> {
-  readonly kind: 'native';
+  readonly kind: "native";
   /** Adapter name that owns the declaration. */
   readonly dialect: TDialect;
   /** Exact dialect declaration, preserved without normalization. */
@@ -605,7 +848,7 @@ type ColumnStorageDialectOf<T> = Extract<ColumnStorageOf<T>, NativeColumnStorage
 /** Extract the exact native declaration from a column definition. */
 type ColumnStorageDeclarationOf<T> = Extract<ColumnStorageOf<T>, NativeColumnStorage> extends NativeColumnStorage<any, infer TDeclaration> ? TDeclaration : never;
 /** Extract the descriptor discriminant from a column definition. */
-type ColumnStorageKindOf<T> = Extract<ColumnStorageOf<T>, ColumnStorage>['kind'];
+type ColumnStorageKindOf<T> = Extract<ColumnStorageOf<T>, ColumnStorage>["kind"];
 /** Short alias for {@link ColumnStorageOf}. */
 type StorageOf<T> = ColumnStorageOf<T>;
 /** Alias matching the existing `ColumnSqlType` extraction naming. */
@@ -635,12 +878,12 @@ interface ColumnOptions {
   /** Override adapter decoding for values selected from this column. */
   readonly decode?: ResultDecoder;
   /**
-   * Raw SQL target that makes a custom definition reusable with cast().
-   * The value is emitted verbatim and must come from trusted source code.
+   * Raw SQL target that makes a custom definition reusable with cast(). The value is emitted
+   * verbatim and must come from trusted source code.
    */
   readonly castType?: string;
 }
-type BuiltInColumnOptions = Omit<ColumnOptions, 'castType' | 'storage'> & {
+type BuiltInColumnOptions = Omit<ColumnOptions, "castType" | "storage"> & {
   readonly castType?: never;
   readonly storage?: never;
 };
@@ -672,20 +915,20 @@ interface ColumnDefinitionConfig {
   readonly onUpdate?: AnySchemaExpression;
 }
 type ConfigValue<TConfig, TKey extends PropertyKey, TFallback> = TKey extends keyof TConfig ? TConfig[TKey] : TFallback;
-type ColumnConfigOutput<TConfig> = ConfigValue<TConfig, 'output', unknown>;
+type ColumnConfigOutput<TConfig> = ConfigValue<TConfig, "output", unknown>;
 type ConfigBoolean<TConfig, TKey extends PropertyKey> = Extract<ConfigValue<TConfig, TKey, false>, boolean> extends (infer TValue) ? [TValue] extends [never] ? false : TValue : false;
-type ColumnConfigNullable<TConfig> = ConfigBoolean<TConfig, 'nullable'>;
-type ColumnConfigInsert<TConfig> = ConfigValue<TConfig, 'insert', ColumnConfigOutput<TConfig>>;
-type ColumnConfigUpdate<TConfig> = ConfigValue<TConfig, 'update', ColumnConfigInsert<TConfig>>;
-type ColumnConfigHasDefault<TConfig> = ConfigBoolean<TConfig, 'hasDefault'>;
-type ColumnConfigGenerated<TConfig> = ConfigBoolean<TConfig, 'generated'>;
-type ColumnConfigSqlType<TConfig> = Extract<ConfigValue<TConfig, 'sqlType', SqlUnknown>, AnySqlType> extends (infer TValue) ? [TValue] extends [never] ? SqlUnknown : TValue : SqlUnknown;
-type ColumnConfigStorage<TConfig> = ConfigValue<TConfig, 'storage', undefined>;
-type ColumnConfigDefault<TConfig> = ConfigValue<TConfig, 'default', undefined>;
-type ColumnConfigGeneratedColumn<TConfig> = ConfigValue<TConfig, 'generatedColumn', undefined>;
-type ColumnConfigIdentity<TConfig> = ConfigValue<TConfig, 'identity', undefined>;
-type ColumnConfigOnUpdate<TConfig> = ConfigValue<TConfig, 'onUpdate', undefined>;
-type SetColumnOutput<TConfig, TOutput> = Omit<TConfig, 'output' | 'insert' | 'update'> & {
+type ColumnConfigNullable<TConfig> = ConfigBoolean<TConfig, "nullable">;
+type ColumnConfigInsert<TConfig> = ConfigValue<TConfig, "insert", ColumnConfigOutput<TConfig>>;
+type ColumnConfigUpdate<TConfig> = ConfigValue<TConfig, "update", ColumnConfigInsert<TConfig>>;
+type ColumnConfigHasDefault<TConfig> = ConfigBoolean<TConfig, "hasDefault">;
+type ColumnConfigGenerated<TConfig> = ConfigBoolean<TConfig, "generated">;
+type ColumnConfigSqlType<TConfig> = Extract<ConfigValue<TConfig, "sqlType", SqlUnknown>, AnySqlType> extends (infer TValue) ? [TValue] extends [never] ? SqlUnknown : TValue : SqlUnknown;
+type ColumnConfigStorage<TConfig> = ConfigValue<TConfig, "storage", undefined>;
+type ColumnConfigDefault<TConfig> = ConfigValue<TConfig, "default", undefined>;
+type ColumnConfigGeneratedColumn<TConfig> = ConfigValue<TConfig, "generatedColumn", undefined>;
+type ColumnConfigIdentity<TConfig> = ConfigValue<TConfig, "identity", undefined>;
+type ColumnConfigOnUpdate<TConfig> = ConfigValue<TConfig, "onUpdate", undefined>;
+type SetColumnOutput<TConfig, TOutput> = Omit<TConfig, "output" | "insert" | "update"> & {
   readonly output: TOutput;
   readonly insert: SameType<ColumnConfigInsert<TConfig>, ColumnConfigOutput<TConfig>> extends true ? TOutput : ColumnConfigInsert<TConfig>;
   readonly update: SameType<ColumnConfigUpdate<TConfig>, ColumnConfigOutput<TConfig>> extends true ? TOutput : ColumnConfigUpdate<TConfig>;
@@ -693,7 +936,7 @@ type SetColumnOutput<TConfig, TOutput> = Omit<TConfig, 'output' | 'insert' | 'up
 interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   /** @internal Type-level configuration retained for inference. */
   readonly __config?: TConfig;
-  readonly definitionKind: 'column';
+  readonly definitionKind: "column";
   readonly nullable: ColumnConfigNullable<TConfig>;
   readonly hasDefault: ColumnConfigHasDefault<TConfig>;
   readonly generated: ColumnConfigGenerated<TConfig>;
@@ -716,11 +959,11 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   readonly __insert?: ColumnConfigInsert<TConfig>;
   readonly __update?: ColumnConfigUpdate<TConfig>;
   /**
-   * Narrow the column's application type without changing its runtime
-   * definition.
+   * Narrow the column's application type without changing its runtime definition.
    *
-   * @remarks Distinct insert or update types are preserved. This method does
-   * not validate values or add a database constraint.
+   * @remarks
+   *   Distinct insert or update types are preserved. This method does not validate values or add a
+   *   database constraint.
    */
   readonly $type: <const TType extends ColumnConfigOutput<TConfig>>() => ColumnDefinition<SetColumnOutput<TConfig, TType>> & (this extends {
     readonly castTarget: infer TCastTarget extends CastTarget;
@@ -731,26 +974,26 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
 }
 type Flag<T extends boolean | undefined> = T extends true ? true : false;
 type HasExplicitOption<TOptions, TKey extends PropertyKey> = TKey extends keyof TOptions ? {} extends Pick<TOptions, TKey> ? false : true : false;
-type ColumnHasDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, 'default'> extends true ? true : Flag<TOptions['hasDefault']>;
+type ColumnHasDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, "default"> extends true ? true : Flag<TOptions["hasDefault"]>;
 type ColumnIsGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
   readonly generatedColumn: GeneratedColumnDescriptor;
 } ? true : TOptions extends {
   readonly identity: IdentityDescriptor;
-} ? true : Flag<TOptions['generated']>;
-type ColumnDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, 'default'> extends true ? TOptions extends {
+} ? true : Flag<TOptions["generated"]>;
+type ColumnDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, "default"> extends true ? TOptions extends {
   readonly default: infer TDefault;
-} ? TDefault extends AnySchemaExpression ? ExpressionDefaultDescriptor<TDefault> : TDefault extends ExternalDefaultDescriptor ? TDefault : TDefault extends SchemaLiteralValue ? LiteralDefaultDescriptor : never : never : TOptions['hasDefault'] extends true ? ExternalDefaultDescriptor : undefined;
+} ? TDefault extends AnySchemaExpression ? ExpressionDefaultDescriptor<TDefault> : TDefault extends ExternalDefaultDescriptor ? TDefault : TDefault extends SchemaLiteralValue ? LiteralDefaultDescriptor : never : never : TOptions["hasDefault"] extends true ? ExternalDefaultDescriptor : undefined;
 type ColumnGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
   readonly generatedColumn: infer TGenerated extends GeneratedColumnDescriptor;
-} ? TGenerated : TOptions['generated'] extends true ? ExternalGeneratedColumnDescriptor : undefined;
+} ? TGenerated : TOptions["generated"] extends true ? ExternalGeneratedColumnDescriptor : undefined;
 type ColumnIdentityOption<TOptions extends ColumnOptions> = TOptions extends {
   readonly identity: infer TIdentity extends IdentityDescriptor;
 } ? TIdentity : undefined;
 type ColumnOnUpdateOption<TOptions extends ColumnOptions> = TOptions extends {
   readonly onUpdate: infer TOnUpdate extends AnySchemaExpression;
 } ? TOnUpdate : undefined;
-type IsAny$1<T> = 0 extends 1 & T ? true : false;
-type SameType<TLeft, TRight> = IsAny$1<TLeft> extends true ? IsAny$1<TRight> : IsAny$1<TRight> extends true ? false : [TLeft] extends [TRight] ? [TRight] extends [TLeft] ? true : false : false;
+type IsAny<T> = 0 extends 1 & T ? true : false;
+type SameType<TLeft, TRight> = IsAny<TLeft> extends true ? IsAny<TRight> : IsAny<TRight> extends true ? false : [TLeft] extends [TRight] ? [TRight] extends [TLeft] ? true : false : false;
 type Simplify$1<T> = { readonly [TKey in keyof T]: T[TKey]; };
 type ColumnValueConfig<TOutput, TInsert, TUpdate> = {
   readonly output: TOutput;
@@ -761,7 +1004,7 @@ type ColumnValueConfig<TOutput, TInsert, TUpdate> = {
 });
 type TrueConfig<TKey extends PropertyKey, TValue> = TValue extends true ? { readonly [TField in TKey]: true; } : {};
 type DefinedConfig<TKey extends PropertyKey, TValue> = [TValue] extends [undefined] ? {} : { readonly [TField in TKey]: TValue; };
-type ColumnOptionConfig<TOptions extends ColumnOptions> = Simplify$1<TrueConfig<'nullable', Flag<TOptions['nullable']>> & TrueConfig<'hasDefault', ColumnHasDefaultOption<TOptions>> & TrueConfig<'generated', ColumnIsGeneratedOption<TOptions>> & DefinedConfig<'default', ColumnDefaultOption<TOptions>> & DefinedConfig<'generatedColumn', ColumnGeneratedOption<TOptions>> & DefinedConfig<'identity', ColumnIdentityOption<TOptions>> & DefinedConfig<'onUpdate', ColumnOnUpdateOption<TOptions>> & (TOptions extends {
+type ColumnOptionConfig<TOptions extends ColumnOptions> = Simplify$1<TrueConfig<"nullable", Flag<TOptions["nullable"]>> & TrueConfig<"hasDefault", ColumnHasDefaultOption<TOptions>> & TrueConfig<"generated", ColumnIsGeneratedOption<TOptions>> & DefinedConfig<"default", ColumnDefaultOption<TOptions>> & DefinedConfig<"generatedColumn", ColumnGeneratedOption<TOptions>> & DefinedConfig<"identity", ColumnIdentityOption<TOptions>> & DefinedConfig<"onUpdate", ColumnOnUpdateOption<TOptions>> & (TOptions extends {
   readonly storage: infer TStorage extends ColumnStorage;
 } ? {
   readonly storage: TStorage;
@@ -833,7 +1076,7 @@ type AnyColumnDefinition = ColumnDefinition<any>;
 type NamedCastColumn<TDefinition extends AnyColumnDefinition> = TDefinition & {
   readonly castTarget: NamedCastTarget;
 };
-declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TStorage extends ColumnStorage = ColumnStorage, const TOptions extends Omit<ColumnOptions, 'storage'> = Omit<ColumnOptions, 'storage'>>(options: TOptions & {
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TStorage extends ColumnStorage = ColumnStorage, const TOptions extends Omit<ColumnOptions, "storage"> = Omit<ColumnOptions, "storage">>(options: TOptions & {
   readonly storage: TStorage;
 }): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions & {
   readonly storage: TStorage;
@@ -929,7 +1172,7 @@ declare function columnResultValue(definition: {
   readonly storage?: ColumnStorage;
   readonly resultDecoder?: ResultDecoder;
 }): ResultValueMetadata | undefined;
-type NativeColumnOptions = Omit<ColumnOptions, 'storage'> & {
+type NativeColumnOptions = Omit<ColumnOptions, "storage"> & {
   readonly storage?: never;
 };
 type NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends NativeColumnOptions, TSqlType extends AnySqlType, TDialect extends string, TDeclaration extends string> = ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
@@ -948,527 +1191,30 @@ declare function nativeColumn<const TDialect extends string, const TDeclaration
 declare function nullable<TConfig extends ColumnDefinitionConfig>(definition: ColumnDefinition<TConfig>): ColumnDefinition<Simplify$1<Omit<TConfig, "nullable"> & {
   readonly nullable: true;
 }>>;
-declare function integer<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlInteger, 'integer', 'integer', TOptions>;
-declare function numeric<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlDecimal, 'numeric', 'decimal', TOptions>;
-declare function text<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlText, 'text', 'text', TOptions>;
-declare function boolean<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<boolean, SqlBoolean, 'boolean', 'boolean', TOptions>;
-declare function date<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlDate, 'date', 'date', TOptions>;
-declare function timestamp<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlTimestamp, 'timestamp', 'timestamp', TOptions>;
-declare function uuid<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlUuid, 'uuid', 'uuid', TOptions>;
-declare function json<TOutput = unknown, const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<TOutput, SqlJson<TOutput>, 'json', 'json', TOptions>;
-declare function bigint<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<bigint, SqlBigInt, 'bigint', 'bigint', TOptions>;
-declare function binary<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Uint8Array, SqlBinary, 'binary', 'binary', TOptions>;
+declare function integer<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlInteger, "integer", "integer", TOptions>;
+declare function numeric<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlDecimal, "numeric", "decimal", TOptions>;
+declare function text<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlText, "text", "text", TOptions>;
+declare function boolean<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<boolean, SqlBoolean, "boolean", "boolean", TOptions>;
+declare function date<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlDate, "date", "date", TOptions>;
+declare function timestamp<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlTimestamp, "timestamp", "timestamp", TOptions>;
+declare function uuid<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlUuid, "uuid", "uuid", TOptions>;
+declare function json<TOutput = unknown, const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<TOutput, SqlJson<TOutput>, "json", "json", TOptions>;
+declare function bigint<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<bigint, SqlBigInt, "bigint", "bigint", TOptions>;
+declare function binary<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Uint8Array, SqlBinary, "binary", "binary", TOptions>;
 //#endregion
-//#region src/schema/column-nullability.d.ts
-declare const declaredColumnNullability: unique symbol;
-/** Compile-time nullability retained by a column from its table declaration. */
-type DeclaredColumnNullability<TNullable extends boolean> = {
-  readonly [declaredColumnNullability]: TNullable;
+//#region src/expressions/cast.d.ts
+type CastDefinition = ColumnDefinition<any> & {
+  readonly nullable: false;
+  readonly castTarget: CastTarget;
 };
-/** @internal */
-type DeclaredColumnNullabilityOf<TColumn> = TColumn extends DeclaredColumnNullability<infer TNullable> ? TNullable : never;
-//#endregion
-//#region src/schema/constraints.d.ts
-declare const fieldConstraint: unique symbol;
-/** Application and SQL facts that a reusable source field may require. */
-interface FieldLikeOptions {
-  readonly output?: unknown;
-  readonly sqlType?: object;
-  readonly nullable?: boolean;
-}
 /**
- * A reusable source-field requirement combining application and SQL facts.
- * Omitted facts impose no constraint; `nullable: false` requires a non-null
- * selected value.
- */
-interface FieldLike<TOptions extends FieldLikeOptions = FieldLikeOptions> {
-  readonly [fieldConstraint]: TOptions;
-}
-type FieldOptions<T> = T extends FieldLike<infer TOptions> ? TOptions : never;
-type RequiredOutput<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
-  readonly output: infer TOutput;
-} ? FieldOptions<T> extends {
-  readonly nullable: false;
-} ? NonNullable<TOutput> : TOutput : FieldOptions<T> extends {
-  readonly nullable: false;
-} ? {} : unknown : T;
-type RequiredSqlType<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
-  readonly sqlType: infer TSqlType;
-} ? (AnySqlType & TSqlType) | SqlUnknown : AnySqlType : AnySqlType;
-type RequiredColumn<TField extends string, TRequirement, TIdentity> = ColumnReference<TField, ResultMeta<RequiredOutput<TRequirement>, TIdentity, RequiredSqlType<TRequirement>> | RequiresSourceMeta<TIdentity> | ExpressionMeta<ColumnDependency<TIdentity, TField>>>;
-type RequiredColumns<TShape extends object, TIdentity> = { readonly [K in keyof TShape]-?: K extends string ? RequiredColumn<K, TShape[K], TIdentity> : never; };
-/**
- * A source containing at least the requested application and SQL fields.
- * Additional fields and the concrete source identity are preserved by generic
- * functions that accept this lower-bound constraint.
- */
-interface SourceLike<TShape extends object> extends Fragment<any> {
-  readonly sourceKind: SourceKind;
-  readonly [sourceIdentity]: unknown;
-  readonly reference: Fragment<never>;
-  readonly columns: RequiredColumns<TShape, this[typeof sourceIdentity]>;
-}
-/** The physical-table form of the lower-bound {@link SourceLike} constraint. */
-interface TableLike<TShape extends object> extends SourceLike<TShape> {
-  readonly tableName: string;
-  readonly definitions: object;
-  readonly sqlNames: Readonly<Record<string, string>>;
-}
-/** Standard SQL referential action retained on a foreign-key constraint. */
-type ReferentialAction = 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
-/** Standard SQL match mode for a composite foreign key. */
-type ForeignKeyMatch = 'simple' | 'full' | 'partial';
-/** Deferrability timing for a foreign-key or key constraint. */
-type ConstraintTiming = 'immediate' | 'deferred';
-/** PostgreSQL-only constraint options retained for a schema adapter. */
-interface PostgresConstraintExtension extends SchemaDialectExtension<'postgresql'> {
-  /** PostgreSQL `NOT VALID` validation state for a constraint. */
-  readonly notValid?: boolean;
-}
-/** SQLite-only table-constraint options. */
-interface SqliteConstraintExtension extends SchemaDialectExtension<'sqlite'> {
-  /** SQLite conflict policy attached to a table constraint. */
-  readonly onConflict?: 'rollback' | 'abort' | 'fail' | 'ignore' | 'replace';
-}
-/** MySQL-only constraint options. */
-interface MysqlConstraintExtension extends SchemaDialectExtension<'mysql'> {
-  /** MySQL 8 constraint enforcement state. */
-  readonly enforced?: boolean;
-}
-/** First-party and user-defined dialect extensions for constraints. */
-type ConstraintDialectExtension = PostgresConstraintExtension | SqliteConstraintExtension | MysqlConstraintExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
-/** Shared physical-name and dialect-extension options for constraints. */
-interface ConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends SchemaObjectNameOptions {
-  /** Engine-specific metadata owned by a future schema adapter. */
-  readonly dialect?: TExtension;
-}
-/** Options for primary-key and candidate-key declarations. */
-interface KeyConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
-  /** Whether the key can be deferred by a supporting dialect. */
-  readonly deferrable?: boolean;
-  /** Initial enforcement timing for a deferrable key. */
-  readonly initially?: ConstraintTiming;
-}
-/** Options for a database unique constraint, including nullable columns. */
-interface UniqueConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
-  /**
-   * SQL NULL comparison semantics. `distinct` is the common default in which
-   * multiple NULL values do not conflict; `not-distinct` permits at most one.
-   */
-  readonly nulls?: UniqueNullSemantics;
-  /** Whether the constraint can be deferred by a supporting dialect. */
-  readonly deferrable?: boolean;
-  /** Initial enforcement timing for a deferrable constraint. */
-  readonly initially?: ConstraintTiming;
-}
-/** Explicit NULL behavior for a database uniqueness rule. */
-type UniqueNullSemantics = 'distinct' | 'not-distinct';
-/** Options for a table check constraint. */
-interface CheckConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
-  /** Whether the check can be deferred by a supporting dialect. */
-  readonly deferrable?: boolean;
-  /** Initial enforcement timing for a deferrable check. */
-  readonly initially?: ConstraintTiming;
-}
-/** Dialect tag and parameter-free SQL needed to reconstruct a catalog check. */
-interface CatalogCheckSql<TDialect extends SchemaDialectName = SchemaDialectName> {
-  /** Catalog dialect that supplied the check expression. */
-  readonly dialect: TDialect;
-  /** Opaque SQL text recovered from the catalog. */
-  readonly sql: string;
-}
-/** Options for a foreign-key declaration. */
-interface ForeignKeyOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
-  readonly onUpdate?: ReferentialAction;
-  readonly onDelete?: ReferentialAction;
-  readonly match?: ForeignKeyMatch;
-  readonly deferrable?: boolean;
-  readonly initially?: ConstraintTiming;
-}
-/** A schema constraint whose columns form a relational key. */
-interface KeyConstraint<TKind extends 'primary-key' | 'unique' = 'primary-key' | 'unique', TColumns extends readonly ColumnReference<string, any>[] = readonly ColumnReference<string, any>[]> extends SchemaObjectIdentity {
-  readonly kind: TKind;
-  readonly columns: TColumns;
-  readonly physicalName?: string;
-  readonly dialect?: ConstraintDialectExtension;
-  readonly deferrable?: boolean;
-  readonly initially?: ConstraintTiming;
-}
-/** A referenced table and exact candidate-key column tuple. */
-interface ForeignKeyTarget<TTable extends TableLike<any> = TableLike<any>, TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[]> {
-  readonly table: TTable;
-  readonly columns: TColumns;
-}
-type ForeignKeyTargetInput<TTarget extends ForeignKeyTarget = ForeignKeyTarget> = TTarget | (() => TTarget);
-/** A foreign key from local columns to a direct or lazily resolved target. */
-interface ForeignKeyConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TTarget extends ForeignKeyTargetInput = ForeignKeyTargetInput> extends SchemaObjectIdentity {
-  readonly kind: 'foreign-key';
-  readonly columns: TColumns;
-  readonly target: TTarget;
-  readonly physicalName?: string;
-  readonly dialect?: ConstraintDialectExtension;
-  readonly onUpdate?: ReferentialAction;
-  readonly onDelete?: ReferentialAction;
-  readonly match?: ForeignKeyMatch;
-  readonly deferrable?: boolean;
-  readonly initially?: ConstraintTiming;
-}
-/** Database uniqueness that deliberately does not prove a candidate key. */
-interface UniqueConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TNulls extends UniqueNullSemantics = UniqueNullSemantics> extends SchemaObjectIdentity {
-  readonly kind: 'unique-constraint';
-  readonly columns: TColumns;
-  readonly nulls: TNulls;
-  readonly physicalName?: string;
-  readonly dialect?: ConstraintDialectExtension;
-  readonly deferrable?: boolean;
-  readonly initially?: ConstraintTiming;
-}
-/** A table-scoped boolean invariant. */
-interface CheckConstraint<TExpression extends AnyExpression = AnyExpression> extends SchemaObjectIdentity {
-  readonly kind: 'check';
-  readonly expression: TExpression;
-  readonly physicalName?: string;
-  readonly dialect?: ConstraintDialectExtension;
-  readonly deferrable?: boolean;
-  readonly initially?: ConstraintTiming;
-}
-/**
- * Opaque catalog SQL whose check-constraint origin proves a boolean SQL
- * semantic type. The expression remains dialect-tagged and parameter-free.
- */
-interface CatalogCheckExpression<TDialect extends SchemaDialectName = SchemaDialectName> extends SchemaExpression<ResultMeta<boolean, never, SqlBoolean> | ExpressionMeta<never>, 'unsafe'> {
-  readonly schemaSqlDialect: TDialect;
-  readonly schemaSql: string;
-}
-/** Structured schema metadata carried by sources that declare constraints. */
-type SourceConstraint = KeyConstraint | UniqueConstraint | ForeignKeyConstraint | CheckConstraint;
-/** Named schema constraints attached to a source. */
-type SourceConstraintsRecord = Readonly<Record<string, SourceConstraint>>;
-/**
- * Validate one constraint against a schema adapter dialect. This is kept
- * separate from construction because the same declaration can be inspected
- * for more than one target dialect before a serializer is selected.
- */
-declare function validateConstraintDialect(constraint: SourceConstraint, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
-type AnyKeyColumn = ColumnReference<string, any>;
-type ColumnSource<TColumn> = DependenciesOf<TColumn> extends ColumnDependency<infer TSource, string> ? TSource : never;
-type IsNullableKeyColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
-type InvalidKeyColumn<TColumn, TSource> = TColumn extends AnyKeyColumn ? IsNullableKeyColumn<TColumn> extends true ? TColumn : DependenciesOf<TColumn> extends ColumnDependency<TSource, string> ? never : TColumn : TColumn;
-type KeyColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: InvalidKeyColumn<TColumns[K], ColumnSource<TColumns[0]>>; }[number]] extends [never] ? unknown : never;
-type SameSourceColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: TColumns[K] extends AnyKeyColumn ? DependenciesOf<TColumns[K]> extends ColumnDependency<ColumnSource<TColumns[0]>, string> ? never : TColumns[K] : TColumns[K]; }[number]] extends [never] ? unknown : never;
-type SameSqlDomain<TLeft, TRight> = SqlTypeOf<TLeft> extends (infer TLeftSql) ? SqlTypeOf<TRight> extends (infer TRightSql) ? TLeftSql extends SqlUnknown ? false : TRightSql extends SqlUnknown ? false : TLeftSql extends AnySqlType ? TRightSql extends AnySqlType ? string extends TLeftSql['sqlType'] ? false : string extends TRightSql['sqlType'] ? false : [TLeftSql['sqlType']] extends [TRightSql['sqlType']] ? [TRightSql['sqlType']] extends [TLeftSql['sqlType']] ? true : false : false : false : false : false : false;
-type ForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? SameSqlDomain<TLocalHead, TTargetHead> extends true ? ForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
-type IsUnresolvedSqlDomain<TSqlType> = TSqlType extends SqlUnknown ? true : TSqlType extends AnySqlType ? string extends TSqlType['sqlType'] ? true : false : true;
-type CatalogSqlDomainCompatible<TLeft, TRight> = true extends IsUnresolvedSqlDomain<SqlTypeOf<TLeft>> | IsUnresolvedSqlDomain<SqlTypeOf<TRight>> ? true : SameSqlDomain<TLeft, TRight>;
-type CatalogForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? CatalogSqlDomainCompatible<TLocalHead, TTargetHead> extends true ? CatalogForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
-type CheckExpressionValidation<TExpression> = [SqlTypeOf<TExpression>] extends [never] ? never : SqlTypeOf<TExpression> extends SqlBoolean ? unknown : never;
-/** Declare a primary key, including a composite primary key. */
-declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'primary-key', TColumns>;
-declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'primary-key', TColumns>;
-/** Declare a non-null unique key, including a composite unique key. */
-declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'unique', TColumns>;
-declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<'unique', TColumns>;
-/**
- * Describe database uniqueness without claiming that the columns determine a
- * row. Nullable columns are accepted, and the NULL behavior is explicit in
- * the returned metadata. Use {@link unique} when a type-level key proof is
- * intended.
- */
-declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, 'distinct'>;
-declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends UniqueConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, TOptions extends {
-  readonly nulls: infer TNulls extends UniqueNullSemantics;
-} ? TNulls : 'distinct'>;
-/** Pair a table with the exact columns targeted by a foreign key. */
-declare function references<TTable extends TableLike<any>, const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(table: TTable, ...columns: TColumns): ForeignKeyTarget<TTable, TColumns>;
-type ResolvedTarget$1<T> = T extends (() => infer TResolved) ? TResolved : T;
-/** Declare a single-column or composite foreign key. */
-declare function foreignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? ForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
-/**
- * Reconstruct a foreign key proved by database catalog metadata.
- *
- * @remarks
- * Use this helper for generated or introspection-owned declarations when one
- * or both native SQL domains are unresolved. It accepts unresolved domains,
- * but still rejects known domain mismatches, unequal tuple arity, and local
- * columns from different sources. The enclosing `table()` declaration
- * continues to verify target-column ownership and candidate-key metadata.
- * Resolved targets also receive runtime shape, ownership, and arity checks.
- * The returned value serializes as an ordinary foreign-key constraint.
- */
-declare function catalogForeignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? CatalogForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
-/** Declare a boolean table invariant. */
-declare function check<const TExpression extends Expression<any, any>, const TOptions extends CheckConstraintOptions = {}>(expression: TExpression & CheckExpressionValidation<TExpression>, options?: TOptions): CheckConstraint<TExpression>;
-/**
- * Reconstruct a boolean check from opaque SQL recovered from a database
- * catalog.
- *
- * @remarks
- * This helper records catalog origin as a narrow type-level proof. It
- * gives the opaque expression the {@link SqlBoolean} semantic type without
- * changing the ordinary {@link check} contract. Qubu does not parse or infer
- * dependencies from the SQL. It preserves the text apart from normalizing
- * line endings and retains the dialect tag in serialized schema metadata.
- */
-declare function catalogCheck<const TDialect extends SchemaDialectName, const TOptions extends CheckConstraintOptions = {}>(input: CatalogCheckSql<TDialect>, options?: TOptions): CheckConstraint<CatalogCheckExpression<TDialect>>;
-//#endregion
-//#region src/query/errors.d.ts
-/** Stable diagnostics shared by type-level and runtime query validation. */
-type QueryValidationErrorCode = 'invalid-selection' | 'duplicate-clause' | 'invalid-mutation' | 'unsafe-mutation' | 'invalid-update' | 'invalid-insert' | 'invalid-comparison' | 'invalid-boolean-expression' | 'invalid-pagination' | 'invalid-row-lock' | 'invalid-json-path' | 'missing-source' | 'invalid-grouping' | 'incompatible-sql-domain' | 'incompatible-sql-equality' | 'incompatible-sql-order' | 'incompatible-set-domain' | 'invalid-subquery' | 'invalid-omission' | 'invalid-stream-query' | 'invalid-explain-query' | 'invalid-explain-options' | 'unsupported-explain-option' | 'unsupported-explain-dialect' | 'missing-dialect-capability';
-interface QueryValidationIssue {
-  readonly code: QueryValidationErrorCode;
-  readonly context: string;
-  readonly path: readonly (string | number)[];
-  readonly message: string;
-  readonly hint: string;
-}
-/**
- * A type-level query failure that names the failing rule and the repair path.
- * The legacy detail field is optional so each validator can retain the useful
- * source or clause type in the compiler diagnostic.
- */
-type QueryTypeValidation<TCode extends QueryValidationErrorCode, TContext extends string, THint extends string, TDetail = never> = {
-  readonly __qubu_error_code__: TCode;
-  readonly __qubu_error_context__: TContext;
-  readonly __qubu_error_hint__: THint;
-} & ([TDetail] extends [never] ? unknown : {
-  readonly __qubu_error_detail__: TDetail;
-});
-/** Raised when a query cannot satisfy Qubu's runtime authoring rules. */
-declare class QueryValidationError extends TypeError {
-  readonly name = "QueryValidationError";
-  readonly code: QueryValidationErrorCode;
-  readonly context: string;
-  readonly path: readonly (string | number)[];
-  readonly hint: string;
-  readonly issue: QueryValidationIssue;
-  constructor(issue: QueryValidationIssue);
-}
-//#endregion
-//#region src/core/render.d.ts
-type DefaultDialectCapability = 'json';
-interface RenderedQuery {
-  readonly text: string;
-  readonly parameters: readonly unknown[];
-}
-interface RenderOptions<TCapabilities extends DialectCapability = DialectCapability> {
-  readonly dialect?: Dialect<TCapabilities>;
-}
-type IsAny<T> = 0 extends 1 & T ? true : false;
-type MissingCapabilities<TQuery, TCapabilities extends DialectCapability> = IsAny<CapabilitiesOf<TQuery>> extends true ? never : Exclude<CapabilitiesOf<TQuery>, TCapabilities>;
-type RenderCapabilityValidation<TQuery, TCapabilities extends DialectCapability> = [MissingCapabilities<TQuery, TCapabilities>] extends [never] ? unknown : QueryTypeValidation<'missing-dialect-capability', 'render.dialect', 'Provide a dialect that supports every capability required by the query.', MissingCapabilities<TQuery, TCapabilities>>;
-declare function render<TQuery extends AnyFragment>(query: TQuery & RenderCapabilityValidation<TQuery, DefaultDialectCapability>): RenderedQuery;
-declare function render<TQuery extends AnyFragment, TCapabilities extends DialectCapability>(query: TQuery & RenderCapabilityValidation<TQuery, TCapabilities>, options: RenderOptions<TCapabilities> | Dialect<TCapabilities>): RenderedQuery;
-//#endregion
-//#region src/execution.d.ts
-type StreamableQuery<TRow extends object = Record<string, unknown>> = QueryWithRow<TRow> & {
-  readonly queryKind: 'select' | 'set';
-};
-/** Rendering policy and cancellation input accepted by query execution. */
-interface ExecutionOptions extends RenderOptions {
-  /** Passed to the application adapter for drivers that support cancellation. */
-  readonly signal?: AbortSignal;
-}
-/** Rendering, EXPLAIN, and cancellation options for plan requests. */
-interface ExplainOptions extends RenderOptions, ExplainRenderOptions {
-  /** Passed to the application adapter for drivers that support cancellation. */
-  readonly signal?: AbortSignal;
-}
-/** EXPLAIN options accepted for SELECT and set-operation queries. */
-type ExplainReadOptions = ExplainOptions;
-/** EXPLAIN options for mutations, which never run with analysis enabled. */
-type ExplainMutationOptions = Omit<ExplainOptions, 'analyze'> & {
-  readonly analyze?: never;
-};
-/** Select read-only or plan-only EXPLAIN options from the query kind. */
-type ExplainOptionsFor<TQuery extends AnyQuery> = TQuery['queryKind'] extends 'select' | 'set' ? ExplainReadOptions : ExplainMutationOptions;
-/** Controls the lifecycle of one adapter-owned transaction. */
-interface TransactionOptions {
-  /** Passed to the adapter for transaction begin, commit, and rollback. */
-  readonly signal?: AbortSignal;
-}
-/** One rendered statement and the controls passed to an application adapter. */
-interface ExecutionRequest {
-  /** SQL text and raw application parameters produced by Qubu's renderer. */
-  readonly statement: RenderedQuery;
-  /** The source query kind, available without parsing rendered SQL. */
-  readonly queryKind: QueryKind;
-  /** Named logical fields used by Qubu after the adapter returns raw rows. */
-  readonly resultShape: ResultShape;
-  /** Present when the caller supplied an abort signal to {@link execute} or {@link stream}. */
-  readonly signal?: AbortSignal;
-}
-/** One rendered EXPLAIN statement and the controls passed to an adapter. */
-interface ExplainRequest extends ExecutionRequest {}
-/**
- * Driver-neutral rows and optional mutation facts returned by an adapter.
- *
- * Adapters normalize driver result fields into this shape. They should omit a
- * mutation fact when the driver cannot report it accurately.
- */
-interface ExecutionResult<TRow extends object = Record<string, unknown>> {
-  /** Decoded result rows. Mutations without `RETURNING` use an empty array. */
-  readonly rows: readonly TRow[];
-  /** Rows inserted, updated, or deleted when the driver reports that count. */
-  readonly affectedRows?: number | bigint;
-  /** Rows whose stored values changed when distinct from affected rows. */
-  readonly changedRows?: number | bigint;
-  /** An insert identifier reported by the driver, including generated IDs. */
-  readonly insertId?: string | number | bigint;
-}
-/** Driver-normalized rows and mutation facts returned to Qubu by an adapter. */
-interface AdapterExecutionResult {
-  /** Object rows keyed by the query's rendered result aliases. */
-  readonly rows: readonly Readonly<Record<string, unknown>>[];
-  readonly affectedRows?: number | bigint;
-  readonly changedRows?: number | bigint;
-  readonly insertId?: string | number | bigint;
-}
-/** Adapter-decoded vendor plan rows returned by an EXPLAIN request. */
-interface ExplainResult<TPlanRow extends object = Record<string, unknown>> {
-  /** Opaque plan rows in the shape selected by the application adapter. */
-  readonly rows: readonly TPlanRow[];
-}
-/**
- * The driver-facing boundary. `request.statement.parameters` contains raw
- * application values in placeholder order; the adapter binds and encodes them
- * for its driver. Connection pooling, transactions, retries, and proprietary
- * driver-row normalization remain adapter concerns. Qubu applies the adapter's
- * registered logical result decoders afterward.
- */
-interface QueryAdapter {
-  /** Default rendering policy for queries sent through this adapter. */
-  readonly dialect: Dialect;
-  /** Driver-specific conversions for portable logical result domains. */
-  readonly decoders?: ResultDecoders;
-  /** Execute one request and normalize the driver's result fields. */
-  execute(request: ExecutionRequest): Promise<AdapterExecutionResult>;
-}
-/**
- * An opt-in adapter capability for typed, adapter-decoded EXPLAIN results.
- *
- * Qubu renders and validates the statement. The adapter binds parameters,
- * executes the plan request, owns cancellation and connection lifecycle, and
- * decodes vendor-specific plan rows without a cross-dialect Qubu plan tree.
- */
-interface ExplainableQueryAdapter<TPlanRow extends object = Record<string, unknown>> extends QueryAdapter {
-  explain(request: ExplainRequest): Promise<ExplainResult<TPlanRow>>;
-}
-/** Extract the plan-row type owned by an explainable adapter. */
-type ExplainPlanRow<TAdapter extends ExplainableQueryAdapter> = TAdapter extends ExplainableQueryAdapter<infer TPlanRow> ? TPlanRow : never;
-/**
- * An opt-in adapter capability for streaming rows from read queries.
- *
- * The adapter owns the returned iterator and every resource behind it. The
- * iterator must release those resources when it completes, is closed early,
- * fails, or observes an aborted request signal.
- */
-interface StreamingQueryAdapter extends QueryAdapter {
-  /** Return an adapter-owned object-row stream for one SELECT or set query. */
-  stream(request: ExecutionRequest): AsyncIterable<Readonly<Record<string, unknown>>>;
-}
-type QueryExecutor = QueryAdapter;
-/**
- * An adapter that can pin one driver connection for a callback transaction.
- * The callback receives an adapter scoped to that transaction. Qubu does not
- * issue transaction SQL or manage the driver's connection lifecycle.
- */
-interface TransactionalQueryAdapter<TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QueryAdapter {
-  transaction<T>(callback: (adapter: TTransactionAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
-}
-/** A transaction-capable streaming adapter whose scoped client can stream. */
-type StreamingTransactionalQueryAdapter = StreamingQueryAdapter & TransactionalQueryAdapter<StreamingQueryAdapter>;
-/** A query client with one application-owned adapter bound to every call. */
-interface QubuClient<TAdapter extends QueryAdapter = QueryAdapter> {
-  /** The adapter supplied to {@link qubu}. */
-  readonly adapter: TAdapter;
-  /** Execute a query and keep the adapter's structured mutation facts. */
-  execute<TRow extends object>(query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
-  /** Execute a query and return only its decoded rows. */
-  rows<TRow extends object>(query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<readonly TRow[]>;
-}
-/** A bound client whose adapter also decodes vendor-specific EXPLAIN rows. */
-interface QubuExplainableClient<TAdapter extends ExplainableQueryAdapter = ExplainableQueryAdapter> extends QubuClient<TAdapter> {
-  /** Explain a query without executing it and return adapter-owned plan rows. */
-  explain<TQuery extends AnyQuery>(query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
-}
-/** A bound client whose adapter also supports typed read-query streams. */
-interface QubuStreamingClient<TAdapter extends StreamingQueryAdapter = StreamingQueryAdapter> extends QubuClient<TAdapter> {
-  /** Stream decoded rows without materializing the complete result. */
-  stream<TRow extends object>(query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
-}
-/** A bound client that supports both streaming and typed EXPLAIN plans. */
-interface QubuStreamingExplainableClient<TAdapter extends StreamingQueryAdapter & ExplainableQueryAdapter = StreamingQueryAdapter & ExplainableQueryAdapter> extends QubuStreamingClient<TAdapter>, QubuExplainableClient<TAdapter> {}
-type QubuClientFor<TAdapter extends QueryAdapter> = TAdapter extends StreamingQueryAdapter ? TAdapter extends ExplainableQueryAdapter ? QubuStreamingExplainableClient<TAdapter> : QubuStreamingClient<TAdapter> : TAdapter extends ExplainableQueryAdapter ? QubuExplainableClient<TAdapter> : QubuClient<TAdapter>;
-/** The client available inside a transaction callback. */
-type QubuTransaction = QubuClient<QueryAdapter>;
-/** The streaming client available inside a streaming transaction callback. */
-type QubuStreamingTransaction = QubuStreamingClient<StreamingQueryAdapter>;
-/** A bound client whose adapter supports transaction-scoped execution. */
-interface QubuTransactionalClient<TAdapter extends TransactionalQueryAdapter = TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QubuClient<TAdapter> {
-  /** Run several queries on one adapter-owned transaction. */
-  transaction<T>(callback: (transaction: QubuClientFor<TTransactionAdapter>) => Promise<T>, options?: TransactionOptions): Promise<T>;
-}
-/** A bound EXPLAIN client with an adapter-owned transaction callback. */
-type QubuExplainableTransactionalClient<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter = ExplainableQueryAdapter & TransactionalQueryAdapter, TTransactionAdapter extends QueryAdapter = QueryAdapter> = QubuExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, TTransactionAdapter>;
-/** A bound streaming and EXPLAIN client with an adapter-owned transaction. */
-type QubuExplainableStreamingTransactionalClient<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter = ExplainableQueryAdapter & StreamingTransactionalQueryAdapter> = QubuStreamingExplainableClient<TAdapter> & QubuTransactionalClient<TAdapter, StreamingQueryAdapter>;
-/** A bound streaming client whose transaction callback can also stream. */
-interface QubuStreamingTransactionalClient<TAdapter extends StreamingTransactionalQueryAdapter = StreamingTransactionalQueryAdapter> extends QubuStreamingClient<TAdapter> {
-  /** Run a callback whose streams must be consumed or closed before it resolves. */
-  transaction<T>(callback: (transaction: QubuStreamingTransaction) => Promise<T>, options?: TransactionOptions): Promise<T>;
-}
-/** Bind an application-owned adapter once for repeated query execution. */
-declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableStreamingTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter): QubuExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuStreamingTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter> & QubuStreamingClient<TAdapter>;
-declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingClient<TAdapter>;
-declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter): QubuClient<TAdapter>;
-interface DriverValueEncoder<TDriverValue = unknown> {
-  /** Convert one Qubu parameter into the driver's bindable representation. */
-  encode(value: unknown): TDriverValue;
-}
-/**
- * Render a typed query, pass it to an application adapter, and return the
- * adapter's structured result unchanged.
- *
- * Driver errors are not caught or translated.
- */
-declare function execute<TRow extends object>(query: QueryWithRow<TRow>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
-declare function execute<TRow extends object>(adapter: QueryAdapter, query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<ExecutionResult<TRow>>;
-/** Execute a query and return its decoded rows without mutation facts. */
-declare function executeRows<TRow extends object>(query: QueryWithRow<TRow>, adapter: QueryAdapter, options?: ExecutionOptions): Promise<readonly TRow[]>;
-declare function executeRows<TRow extends object>(adapter: QueryAdapter, query: QueryWithRow<TRow>, options?: ExecutionOptions): Promise<readonly TRow[]>;
-/**
- * Render a query as a dialect-specific EXPLAIN request and return the
- * adapter-decoded vendor plan rows. EXPLAIN never calls QueryAdapter.execute.
- */
-declare function explain<TQuery extends AnyQuery, TAdapter extends ExplainableQueryAdapter>(query: TQuery, adapter: TAdapter, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
-declare function explain<TQuery extends AnyQuery, TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter, query: TQuery, options?: ExplainOptionsFor<TQuery>): Promise<ExplainResult<ExplainPlanRow<TAdapter>>>;
-/**
- * Render a SELECT or set-operation query and return the adapter-owned row
- * stream. Mutations, including mutations with RETURNING, must use execute().
- */
-declare function stream<TRow extends object>(query: StreamableQuery<TRow>, adapter: StreamingQueryAdapter, options?: ExecutionOptions): AsyncIterable<TRow>;
-declare function stream<TRow extends object>(adapter: StreamingQueryAdapter, query: StreamableQuery<TRow>, options?: ExecutionOptions): AsyncIterable<TRow>;
-//#endregion
-//#region src/expressions/cast.d.ts
-type CastDefinition = ColumnDefinition<any> & {
-  readonly nullable: false;
-  readonly castTarget: CastTarget;
-};
-/**
- * Cast to a built-in or custom column definition while deriving both result
- * types from that definition. Operand nullability and source facts survive.
+ * Cast to a built-in or custom column definition while deriving both result types from that
+ * definition. Operand nullability and source facts survive.
  */
 declare function cast<TDefinition extends CastDefinition, TExpression extends AnyExpression>(expression: TExpression, definition: TDefinition): ResultExpression<{
   readonly output: ColumnOutput<TDefinition>;
   readonly children: TExpression;
-  readonly kind: 'operator';
+  readonly kind: "operator";
   readonly nullableFrom: NullabilityOf<TExpression>;
   readonly sqlType: ColumnSqlType<TDefinition>;
 }>;
@@ -1476,7 +1222,7 @@ declare function cast<TDefinition extends CastDefinition, TExpression extends An
 declare function cast<T, TSqlType extends AnySqlType = SqlUnknown, TExpression extends AnyExpression = AnyExpression, const TType extends string = string>(expression: TExpression, typeName: TType): ResultExpression<{
   readonly output: T;
   readonly children: TExpression;
-  readonly kind: 'operator';
+  readonly kind: "operator";
   readonly nullableFrom: NullabilityOf<TExpression>;
   readonly sqlType: TSqlType;
 }>;
@@ -1499,10 +1245,10 @@ declare function typedCast<T, TSqlType extends AnySqlType>(): <TExpression exten
 type MappedOutput<TOutput, TExpression> = TOutput | Extract<ExpressionOutput<TExpression>, null>;
 type MappedResultMetadata<TOutput, TExpression> = ResultMeta<MappedOutput<TOutput, TExpression>, NullabilityOf<TExpression>, SqlTypeOf<TExpression>> | ExpressionMeta<DependenciesOf<TExpression>> | InheritedMetadata<TExpression>;
 /** Attach an application decoder to an expression without changing its SQL. */
-declare function mapResult<TOutput, TExpression extends AnyExpression>(expression: TExpression, decoder: ResultDecoder<TOutput>): TExpression extends AnySchemaExpression ? SchemaExpression<MappedResultMetadata<TOutput, TExpression>, TExpression['expressionKind']> : Expression<MappedResultMetadata<TOutput, TExpression>, TExpression['expressionKind']>;
+declare function mapResult<TOutput, TExpression extends AnyExpression>(expression: TExpression, decoder: ResultDecoder<TOutput>): TExpression extends AnySchemaExpression ? SchemaExpression<MappedResultMetadata<TOutput, TExpression>, TExpression["expressionKind"]> : Expression<MappedResultMetadata<TOutput, TExpression>, TExpression["expressionKind"]>;
 //#endregion
 //#region src/expressions/value.d.ts
-interface ValueExpression<T = unknown, TSqlType extends AnySqlType = SqlUnknown> extends SchemaExpression<ResultMeta<T, never, TSqlType> | ExpressionMeta<never>, 'value'> {
+interface ValueExpression<T = unknown, TSqlType extends AnySqlType = SqlUnknown> extends SchemaExpression<ResultMeta<T, never, TSqlType> | ExpressionMeta<never>, "value"> {
   readonly value: T;
 }
 declare function value<T>(input: T): ValueExpression<T>;
@@ -1515,11 +1261,11 @@ type Operand<T> = T | ExpressionWithOutput<T>;
 /** Plain values are contextually typed by the expression beside them. */
 type OperandSqlType<T, TContext extends AnySqlType> = T extends Fragment<any> ? SqlTypeOf<T> : TContext;
 /** Type-level validation that a known SQL domain provides a capability. */
-type SqlCapabilityValidation<TActual, TCapability> = SqlTypeSatisfies<TActual, TCapability> extends true ? unknown : QueryTypeValidation<'incompatible-sql-domain', 'expression.sql-domain', 'Use an expression with the required SQL domain.', TActual>;
+type SqlCapabilityValidation<TActual, TCapability> = SqlTypeSatisfies<TActual, TCapability> extends true ? unknown : QueryTypeValidation<"incompatible-sql-domain", "expression.sql-domain", "Use an expression with the required SQL domain.", TActual>;
 /** Type-level validation that two known SQL domains can test equality. */
-type SqlEqualityValidation<TLeft, TRight> = SqlEqualityCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<'incompatible-sql-equality', 'comparison.operands', 'Use operands from the same SQL equality group.', readonly [TLeft, TRight]>;
+type SqlEqualityValidation<TLeft, TRight> = SqlEqualityCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<"incompatible-sql-equality", "comparison.operands", "Use operands from the same SQL equality group.", readonly [TLeft, TRight]>;
 /** Type-level validation that two known SQL domains share an ordering group. */
-type SqlOrderValidation<TLeft, TRight> = SqlOrderCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<'incompatible-sql-order', 'comparison.operands', 'Use operands from the same SQL ordering group.', readonly [TLeft, TRight]>;
+type SqlOrderValidation<TLeft, TRight> = SqlOrderCompatible<TLeft, TRight> extends true ? unknown : QueryTypeValidation<"incompatible-sql-order", "comparison.operands", "Use operands from the same SQL ordering group.", readonly [TLeft, TRight]>;
 type OperandNullability<T> = T extends Fragment<any> ? NullabilityOf<T> : never;
 type IsNullOperand<T> = T extends null ? true : T extends ValueExpression<infer TValue> ? [TValue] extends [null] ? true : false : false;
 //#endregion
@@ -1527,7 +1273,7 @@ type IsNullOperand<T> = T extends null ? true : T extends ValueExpression<infer
 type NonNullBooleanResult<TExpression> = ResultExpression<{
   readonly output: boolean;
   readonly children: TExpression;
-  readonly kind: 'operator';
+  readonly kind: "operator";
   readonly nullableFrom: never;
   readonly sqlType: SqlBoolean;
 }>;
@@ -1564,13 +1310,13 @@ declare function notIn<T, TExpression extends ExpressionWithOutput<T>, const TVa
 type ComparisonResult<TLeft, R, TOperator extends string> = ResultExpression<{
   readonly output: boolean;
   readonly children: TLeft | R;
-  readonly kind: 'operator';
-  readonly nullableFrom: TOperator extends 'IS DISTINCT FROM' | 'IS NOT DISTINCT FROM' ? never : TOperator extends '=' | '<>' ? IsNullOperand<R> extends true ? never : NullabilityOf<TLeft> | OperandNullability<R> : NullabilityOf<TLeft> | OperandNullability<R>;
+  readonly kind: "operator";
+  readonly nullableFrom: TOperator extends "IS DISTINCT FROM" | "IS NOT DISTINCT FROM" ? never : TOperator extends "=" | "<>" ? IsNullOperand<R> extends true ? never : NullabilityOf<TLeft> | OperandNullability<R> : NullabilityOf<TLeft> | OperandNullability<R>;
   readonly sqlType: SqlBoolean;
 }>;
 /** SQL-domain validation selected by a comparison operator family. */
-type ComparisonValidation<TLeft, TRight, TOperator extends string> = TOperator extends 'LIKE' | 'NOT LIKE' | 'ILIKE' ? SqlCapabilityValidation<ExpressionSqlType<TLeft>, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<TRight, ExpressionSqlType<TLeft>>, SqlTextLike> : TOperator extends '<' | '<=' | '>' | '>=' ? SqlOrderValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>> : SqlEqualityValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>>;
-declare function eq<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, '='>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+type ComparisonValidation<TLeft, TRight, TOperator extends string> = TOperator extends "LIKE" | "NOT LIKE" | "ILIKE" ? SqlCapabilityValidation<ExpressionSqlType<TLeft>, SqlTextLike> & SqlCapabilityValidation<OperandSqlType<TRight, ExpressionSqlType<TLeft>>, SqlTextLike> : TOperator extends "<" | "<=" | ">" | ">=" ? SqlOrderValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>> : SqlEqualityValidation<ExpressionSqlType<TLeft>, OperandSqlType<TRight, ExpressionSqlType<TLeft>>>;
+declare function eq<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, "=">, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
   readonly kind: "result";
 } ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
   readonly kind: "result";
@@ -1583,7 +1329,7 @@ declare function eq<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<
 } ? T_6 : never : never : never) ? T_5 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, "=">;
-declare function ne<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, '<>'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+declare function ne<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, "<>">, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
   readonly kind: "result";
 } ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
   readonly kind: "result";
@@ -1596,7 +1342,7 @@ declare function ne<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<
 } ? T_6 : never : never : never) ? T_5 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, "<>">;
-declare function lt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '<'>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function lt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, "<">, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1609,7 +1355,7 @@ declare function lt<TLeft extends AnyExpression, R extends Operand<Exclude<Expre
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, "<">;
-declare function lte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '<='>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function lte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, "<=">, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1622,7 +1368,7 @@ declare function lte<TLeft extends AnyExpression, R extends Operand<Exclude<Expr
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, "<=">;
-declare function gt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '>'>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function gt<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, ">">, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1635,7 +1381,7 @@ declare function gt<TLeft extends AnyExpression, R extends Operand<Exclude<Expre
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, ">">;
-declare function gte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, '>='>, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function gte<TLeft extends AnyExpression, R extends Operand<Exclude<ExpressionOutput<TLeft>, null>>>(left: TLeft & ComparisonValidation<TLeft, R, ">=">, right: R): ComparisonResult<TLeft & SqlOrderValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1648,7 +1394,7 @@ declare function gte<TLeft extends AnyExpression, R extends Operand<Exclude<Expr
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, ">=">;
-declare function like<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'LIKE'>, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function like<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, "LIKE">, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1661,7 +1407,7 @@ declare function like<TLeft extends ExpressionWithOutput<string>, R extends Oper
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>, SqlTextLike>, R, "LIKE">;
-declare function notLike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, 'NOT LIKE'>, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
+declare function notLike<TLeft extends ExpressionWithOutput<string>, R extends Operand<string>>(left: TLeft & ComparisonValidation<TLeft, R, "NOT LIKE">, pattern: R): ComparisonResult<TLeft & SqlCapabilityValidation<(MetadataOf<TLeft> extends (infer T) ? T extends MetadataOf<TLeft> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TLeft> extends (infer T_2) ? T_2 extends MetadataOf<TLeft> ? T_2 extends {
   readonly kind: "result";
@@ -1674,7 +1420,7 @@ declare function notLike<TLeft extends ExpressionWithOutput<string>, R extends O
 } ? T_5 : never : never : never) ? T_4 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>, SqlTextLike>, R, "NOT LIKE">;
-declare function isDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, 'IS DISTINCT FROM'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+declare function isDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, "IS DISTINCT FROM">, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
   readonly kind: "result";
 } ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
   readonly kind: "result";
@@ -1687,7 +1433,7 @@ declare function isDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R exte
 } ? T_6 : never : never : never) ? T_5 extends {
   readonly sqlType: infer TSqlType extends AnySqlType;
 } ? TSqlType : SqlUnknown : never : never>>, R, "IS DISTINCT FROM">;
-declare function isNotDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, 'IS NOT DISTINCT FROM'>, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
+declare function isNotDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R extends Operand<NoInfer<T>>>(left: TLeft & ComparisonValidation<TLeft, R, "IS NOT DISTINCT FROM">, right: R): ComparisonResult<TLeft & SqlEqualityValidation<(MetadataOf<TLeft> extends (infer T_1) ? T_1 extends MetadataOf<TLeft> ? T_1 extends {
   readonly kind: "result";
 } ? T_1 : never : never : never) extends (infer T_2) ? T_2 extends (MetadataOf<TLeft> extends (infer T_3) ? T_3 extends MetadataOf<TLeft> ? T_3 extends {
   readonly kind: "result";
@@ -1703,13 +1449,13 @@ declare function isNotDistinctFrom<T, TLeft extends ExpressionWithOutput<T>, R e
 //#endregion
 //#region src/expressions/subquery.d.ts
 type SingleColumn<Row extends object> = keyof Row extends (infer TKey) ? TKey extends keyof Row ? [keyof Row] extends [TKey] ? Row[TKey] : never : never : never;
-type ScalarOutput<TQuery extends AnyQuery> = SingleColumn<QueryRow<TQuery>> | ([CardinalityOf<TQuery>] extends ['exactly-one'] ? never : null);
+type ScalarOutput<TQuery extends AnyQuery> = SingleColumn<QueryRow<TQuery>> | ([CardinalityOf<TQuery>] extends ["exactly-one"] ? never : null);
 type SingleColumnSqlType<TQuery extends AnyQuery> = SingleColumn<QuerySqlTypeMap<TQuery>>;
-declare function scalar<TQuery extends AnyQuery>(query: TQuery): Expression<ResultMeta<ScalarOutput<TQuery>, never, SingleColumnSqlType<TQuery>> | InheritedMetadata<TQuery> | SubqueryMeta, 'subquery'>;
+declare function scalar<TQuery extends AnyQuery>(query: TQuery): Expression<ResultMeta<ScalarOutput<TQuery>, never, SingleColumnSqlType<TQuery>> | InheritedMetadata<TQuery> | SubqueryMeta, "subquery">;
 //#endregion
 //#region src/expressions/operators/comparison/subquery.d.ts
-type IsUnion<T, TWhole = T> = T extends unknown ? [TWhole] extends [T] ? false : true : never;
-type InQueryValidation<TExpression, TQuery> = [keyof QueryRow<TQuery>] extends [never] ? QueryTypeValidation<'invalid-subquery', 'in-query.projection', 'Select exactly one field in the IN subquery.'> : true extends IsUnion<keyof QueryRow<TQuery>> ? QueryTypeValidation<'invalid-subquery', 'in-query.projection', 'Select exactly one field in the IN subquery.'> : SingleColumn<QueryRow<TQuery>> extends ExpressionOutput<TExpression> ? SqlEqualityValidation<ExpressionSqlType<TExpression>, SingleColumn<QuerySqlTypeMap<TQuery>>> : QueryTypeValidation<'incompatible-sql-equality', 'in-query.operands', 'Select a subquery field from the same SQL equality group as the expression.', SingleColumn<QueryRow<TQuery>>>;
+type IsUnion<T, TWhole = T> = T extends unknown ? ([TWhole] extends [T] ? false : true) : never;
+type InQueryValidation<TExpression, TQuery> = [keyof QueryRow<TQuery>] extends [never] ? QueryTypeValidation<"invalid-subquery", "in-query.projection", "Select exactly one field in the IN subquery."> : true extends IsUnion<keyof QueryRow<TQuery>> ? QueryTypeValidation<"invalid-subquery", "in-query.projection", "Select exactly one field in the IN subquery."> : SingleColumn<QueryRow<TQuery>> extends ExpressionOutput<TExpression> ? SqlEqualityValidation<ExpressionSqlType<TExpression>, SingleColumn<QuerySqlTypeMap<TQuery>>> : QueryTypeValidation<"incompatible-sql-equality", "in-query.operands", "Select a subquery field from the same SQL equality group as the expression.", SingleColumn<QueryRow<TQuery>>>;
 declare function inQuery<TExpression extends AnyExpression, TQuery extends AnyQuery>(expression: TExpression & InQueryValidation<TExpression, TQuery>, query: TQuery): SubqueryResultExpression<{
   readonly output: boolean;
   readonly children: TExpression | TQuery;
@@ -1746,10 +1492,10 @@ declare function caseWhen<T, TCondition extends BooleanExpression<any>, TThen ex
 type SqlChild<TValues extends readonly unknown[]> = Extract<TValues[number], AnyFragment>;
 type EmbeddedQueryMetadata<TChild> = TChild extends AnyQuery ? SubqueryMeta : never;
 /**
- * A parameterized SQL template that composes with Qubu expressions and
- * queries through the normal renderer.
+ * A parameterized SQL template that composes with Qubu expressions and queries through the normal
+ * renderer.
  */
-type SqlFragment<TOutput = unknown, TSqlType extends AnySqlType = SqlUnknown, TChild extends AnyFragment = never> = Expression<ResultMeta<TOutput, NullabilityOf<TChild>, TSqlType> | ExpressionMeta<DependenciesOf<TChild>> | InheritedMetadata<TChild> | EmbeddedQueryMetadata<TChild>, 'sql'>;
+type SqlFragment<TOutput = unknown, TSqlType extends AnySqlType = SqlUnknown, TChild extends AnyFragment = never> = Expression<ResultMeta<TOutput, NullabilityOf<TChild>, TSqlType> | ExpressionMeta<DependenciesOf<TChild>> | InheritedMetadata<TChild> | EmbeddedQueryMetadata<TChild>, "sql">;
 /** A SQL template tag with an explicitly declared output and SQL domain. */
 interface TypedSqlTag<TOutput, TSqlType extends AnySqlType = SqlUnknown> {
   <const TValues extends readonly unknown[]>(strings: TemplateStringsArray, ...values: TValues): SqlFragment<TOutput, TSqlType, SqlChild<TValues>>;
@@ -1757,33 +1503,33 @@ interface TypedSqlTag<TOutput, TSqlType extends AnySqlType = SqlUnknown> {
 /** Public call contract for {@link sql}. */
 interface SqlTag extends TypedSqlTag<unknown, SqlUnknown> {
   /**
-   * Declare the application output and SQL semantic domain without changing
-   * how template substitutions render.
+   * Declare the application output and SQL semantic domain without changing how template
+   * substitutions render.
    */
   type<TOutput, TSqlType extends AnySqlType = SqlUnknown>(): TypedSqlTag<TOutput, TSqlType>;
 }
 /**
- * Build trusted SQL syntax while binding every ordinary substitution as a
- * parameter. Qubu fragments remain composable substitutions.
+ * Build trusted SQL syntax while binding every ordinary substitution as a parameter. Qubu fragments
+ * remain composable substitutions.
  *
- * @remarks Template text is trusted and is not parsed. Use `identifier()` from
- * `qubu/core` for runtime identifiers and `unsafeExpression()` for deliberately
- * dynamic syntax. Use `sql.type<Output, SqlType>()` when the fragment's result
- * is known.
+ * @remarks
+ *   Template text is trusted and is not parsed. Use `identifier()` from `qubu/core` for runtime
+ *   identifiers and `unsafeExpression()` for deliberately dynamic syntax. Use `sql.type<Output,
+ *   SqlType>()` when the fragment's result is known.
  */
 declare const sql: SqlTag;
 //#endregion
 //#region src/expressions/functions/aggregate.d.ts
 declare function count(): AggregateResultExpression<{
   readonly output: number;
-  readonly kind: 'function';
+  readonly kind: "function";
   readonly nullableFrom: never;
   readonly sqlType: SqlInteger;
 }>;
 declare function count<TExpression extends AnyExpression>(expression: TExpression): AggregateResultExpression<{
   readonly output: number;
   readonly children: TExpression;
-  readonly kind: 'function';
+  readonly kind: "function";
   readonly nullableFrom: never;
   readonly sqlType: SqlInteger;
 }>;
@@ -1826,9 +1572,9 @@ declare function max<T, TExpression extends ExpressionWithOutput<T>>(expression:
 //#region src/expressions/functions/call.d.ts
 declare function call<TOutput = unknown, const TName extends string = string, const TArguments extends readonly unknown[] = readonly unknown[], TNullableFrom = NullabilityOf<TArguments[number]>, TSqlType extends AnySqlType = SqlUnknown>(name: TName, ...args: TArguments): Expression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TArguments[number]>> | InheritedMetadata<TArguments[number]>, "function">;
 /**
- * Internal built-in function constructor for deterministic schema functions.
- * Arbitrary calls stay on {@link call} and require an explicit schema
- * extension contract before they can be used in schema metadata.
+ * Internal built-in function constructor for deterministic schema functions. Arbitrary calls stay
+ * on {@link call} and require an explicit schema extension contract before they can be used in
+ * schema metadata.
  */
 declare function schemaCall<TOutput = unknown, const TName extends string = string, const TArguments extends readonly unknown[] = readonly unknown[], TNullableFrom = NullabilityOf<TArguments[number]>, TSqlType extends AnySqlType = SqlUnknown>(name: TName, ...args: TArguments): SchemaExpression<ResultMeta<TOutput, TNullableFrom, TSqlType> | ExpressionMeta<DependenciesOf<TArguments[number]>> | InheritedMetadata<TArguments[number]>, "function">;
 /** Declare the SQL result domain of a custom function call. */
@@ -1888,16 +1634,16 @@ declare function concat<const TArguments extends readonly Operand<string>[]>(...
 //#region src/expressions/functions/window.d.ts
 type WindowOrder = AnyExpression | OrderTerm<any>;
 /**
- * The initial inline window scope. Named windows and frame clauses can be
- * added at a later dialect-aware boundary without changing expression types.
+ * The initial inline window scope. Named windows and frame clauses can be added at a later
+ * dialect-aware boundary without changing expression types.
  */
 interface WindowSpec {
   readonly partitionBy?: readonly AnyExpression[];
   readonly orderBy?: readonly WindowOrder[];
 }
 type FragmentItems<T> = T extends readonly unknown[] ? T[number] : never;
-type WindowSpecParts<TWindow> = TWindow extends WindowSpec ? FragmentItems<TWindow['partitionBy']> | FragmentItems<TWindow['orderBy']> : never;
-type WindowedExpression<TExpression extends AnyExpression, TWindow extends WindowSpec | undefined> = Expression<ResultMeta<OutputOf<TExpression>, NullabilityOf<TExpression>, SqlTypeOf<TExpression>> | ExpressionMeta<DependenciesOf<TExpression | WindowSpecParts<TWindow>>> | InheritedMetadata<TExpression | WindowSpecParts<TWindow>> | WindowMeta, 'function'>;
+type WindowSpecParts<TWindow> = TWindow extends WindowSpec ? FragmentItems<TWindow["partitionBy"]> | FragmentItems<TWindow["orderBy"]> : never;
+type WindowedExpression<TExpression extends AnyExpression, TWindow extends WindowSpec | undefined> = Expression<ResultMeta<OutputOf<TExpression>, NullabilityOf<TExpression>, SqlTypeOf<TExpression>> | ExpressionMeta<DependenciesOf<TExpression | WindowSpecParts<TWindow>>> | InheritedMetadata<TExpression | WindowSpecParts<TWindow>> | WindowMeta, "function">;
 declare function over<TExpression extends AnyExpression, const TWindow extends WindowSpec | undefined = undefined>(expression: TExpression, window?: TWindow): WindowedExpression<TExpression, TWindow>;
 declare function rowNumber(): Expression<ExpressionMeta<never> | ResultMeta<number, never, SqlInteger>, "function">;
 declare function rank(): Expression<ExpressionMeta<never> | ResultMeta<number, never, SqlInteger>, "function">;
@@ -1910,7 +1656,7 @@ declare const jsonPathBrand: unique symbol;
 /** An opaque root-relative JSON path whose literal segments remain available to TypeScript. */
 interface JsonPath<TSegments extends readonly JsonPathSegment[] = readonly JsonPathSegment[]> {
   readonly [jsonPathBrand]: true;
-  readonly pathKind: 'json';
+  readonly pathKind: "json";
   readonly segments: TSegments;
 }
 /**
@@ -1919,7 +1665,7 @@ interface JsonPath<TSegments extends readonly JsonPathSegment[] = readonly JsonP
  * @throws {TypeError} When an index is negative, fractional, or unsafe.
  */
 declare function jsonPath<const TSegments extends readonly JsonPathSegment[]>(...segments: TSegments): JsonPath<TSegments>;
-type JsonExpressionMetadata<TOutput, TDocument> = ResultMeta<TOutput> | ExpressionMeta<DependenciesOf<TDocument>> | InheritedMetadata<TDocument> | RequiresCapabilityMeta<'json'>;
+type JsonExpressionMetadata<TOutput, TDocument> = ResultMeta<TOutput> | ExpressionMeta<DependenciesOf<TDocument>> | InheritedMetadata<TDocument> | RequiresCapabilityMeta<"json">;
 /** Extract a JSON string, returning SQL NULL for missing, null, or non-string values. */
 declare function jsonText<TDocument extends AnyExpression, TPath extends JsonPath>(document: TDocument, path: TPath): SchemaExpression<JsonExpressionMetadata<string | null, TDocument>, "function">;
 /** Extract a JSON number, returning SQL NULL for missing, null, or non-number values. */
@@ -2717,160 +2463,487 @@ declare const modulo: <T, TLeft extends ExpressionWithOutput<T>, R extends Opera
   } ? TSqlType : SqlUnknown : never : never;
 }>;
 //#endregion
-//#region src/query/clauses/types.d.ts
-type ClausePlacement = 'before-select' | 'after-select';
-interface SelectClause<TMetadata = any> extends Fragment<TMetadata> {
-  readonly clauseKind: string;
-  readonly placement: ClausePlacement;
-  readonly order: number;
+//#region src/query/clauses/types.d.ts
+type ClausePlacement = "before-select" | "after-select";
+interface SelectClause<TMetadata = any> extends Fragment<TMetadata> {
+  readonly clauseKind: string;
+  readonly placement: ClausePlacement;
+  readonly order: number;
+}
+type AnySelectClause = SelectClause<any>;
+//#endregion
+//#region src/query/clauses/distinct.d.ts
+interface DistinctClause extends SelectClause<never> {
+  readonly clauseKind: "distinct";
+}
+declare function distinct(): DistinctClause;
+//#endregion
+//#region src/query/clauses/having.d.ts
+interface HavingClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: "having";
+  readonly condition: BooleanExpression<any>;
+}
+type HavingComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? HavingClause<InheritedMetadata<TCondition>> : never;
+type HavingValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
+declare function having<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & HavingValidation<TCondition>): HavingComposition<TCondition>;
+//#endregion
+//#region src/query/clauses/pagination.d.ts
+interface OffsetClause extends SelectClause<never> {
+  readonly clauseKind: "offset";
+  readonly rows: number;
+}
+type AnyPaginationClause = OffsetClause | FetchClause;
+declare function offset(rows: number): OffsetClause;
+interface FetchClause<TRows extends number = number> extends SelectClause<never> {
+  readonly clauseKind: "fetch";
+  readonly direction: "FIRST" | "NEXT";
+  readonly rows: TRows;
+}
+declare function fetchFirst<const TRows extends number>(rows: TRows): FetchClause<TRows>;
+declare function fetchNext<const TRows extends number>(rows: TRows): FetchClause<TRows>;
+//#endregion
+//#region src/query/clauses/row-lock.d.ts
+interface RowLockOptions<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> {
+  readonly mode?: TMode;
+  readonly wait?: TWait;
+  readonly waitPolicy?: TWait;
+}
+interface RowLockClause<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> extends SelectClause<RequiresCapabilityMeta<"row-locking">> {
+  readonly clauseKind: "row-lock";
+  readonly mode: TMode;
+  readonly wait: TWait;
+}
+declare function rowLock(): RowLockClause<"update", "default">;
+declare function rowLock<TMode extends RowLockMode>(mode: TMode): RowLockClause<TMode, "default">;
+declare function rowLock<TMode extends RowLockMode, TWait extends RowLockWaitPolicy>(mode: TMode, wait: TWait): RowLockClause<TMode, TWait>;
+declare function rowLock(options: RowLockOptions): RowLockClause;
+//#endregion
+//#region src/query/clauses/where.d.ts
+interface WhereClause<TMetadata = never> extends SelectClause<TMetadata> {
+  readonly clauseKind: "where";
+  readonly condition: BooleanExpression<any>;
+}
+type WhereComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? WhereClause<InheritedMetadata<TCondition>> : never;
+type WhereValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
+declare function where<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & WhereValidation<TCondition>): WhereComposition<TCondition>;
+//#endregion
+//#region src/query/omit.d.ts
+/** An explicit placeholder for a safely omitted SELECT clause or projection field. */
+declare const omit: unique symbol;
+type Omit$1 = typeof omit;
+type OmittableSelectClause = DistinctClause | HavingClause<any> | OrderByClause<any> | OffsetClause | FetchClause | RowLockClause | WhereClause<any>;
+type SelectPart = AnySelectClause | Omit$1;
+type PresentClauses<TParts extends readonly SelectPart[]> = { readonly [TIndex in keyof TParts]: Exclude<TParts[TIndex], Omit$1>; };
+type InvalidOmittedClauses<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? Exclude<TParts[TIndex], Omit$1> extends OmittableSelectClause ? never : Exclude<TParts[TIndex], Omit$1> : never; }[number];
+type OmissionValidation<TParts extends readonly SelectPart[]> = [InvalidOmittedClauses<TParts>] extends [never] ? unknown : QueryTypeValidation<"invalid-omission", "select.omit", "Use omit only for a conditional SELECT clause or projection field.", InvalidOmittedClauses<TParts>>;
+//#endregion
+//#region src/expressions/operators/logic.d.ts
+type BooleanOperand = BooleanExpression<any> | Omit$1;
+type PresentConditions<TConditions extends readonly BooleanOperand[]> = Exclude<TConditions[number], Omit$1>;
+type BooleanComposition<TConditions extends readonly BooleanOperand[]> = [PresentConditions<TConditions>] extends [never] ? Omit$1 : ResultExpression<{
+  readonly output: boolean;
+  readonly children: PresentConditions<TConditions>;
+  readonly kind: "operator";
+  readonly nullableFrom: NullabilityOf<PresentConditions<TConditions>>;
+  readonly sqlType: SqlBoolean;
+}> | (Omit$1 extends TConditions[number] ? Omit$1 : never);
+type BooleanConditionsValidation<TConditions extends readonly unknown[]> = TConditions extends readonly [infer THead, ...infer TTail] ? (THead extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<THead>, SqlBoolean>) & BooleanConditionsValidation<TTail> : unknown;
+declare function and<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
+declare function or<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
+declare function not<TCondition extends BooleanExpression<any>>(condition: TCondition & SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>): ResultExpression<{
+  readonly output: boolean;
+  readonly children: TCondition;
+  readonly kind: "operator";
+  readonly nullableFrom: NullabilityOf<TCondition>;
+  readonly sqlType: SqlBoolean;
+}>;
+//#endregion
+//#region src/schema/column-nullability.d.ts
+declare const declaredColumnNullability: unique symbol;
+/** Compile-time nullability retained by a column from its table declaration. */
+type DeclaredColumnNullability<TNullable extends boolean> = {
+  readonly [declaredColumnNullability]: TNullable;
+};
+/** @internal */
+type DeclaredColumnNullabilityOf<TColumn> = TColumn extends DeclaredColumnNullability<infer TNullable> ? TNullable : never;
+//#endregion
+//#region src/schema/indexes.d.ts
+type IndexTerm = AnyExpression | OrderTerm<any>;
+/** PostgreSQL-specific index method and storage metadata. */
+interface PostgresIndexExtension extends SchemaDialectExtension<"postgresql"> {
+  readonly method?: "btree" | "hash" | "gist" | "spgist" | "gin" | "brin";
+  readonly concurrently?: boolean;
+  readonly operatorClasses?: Readonly<Record<string, string>>;
+  readonly storageParameters?: Readonly<Record<string, string | number | boolean>>;
 }
-type AnySelectClause = SelectClause<any>;
-//#endregion
-//#region src/query/clauses/distinct.d.ts
-interface DistinctClause extends SelectClause<never> {
-  readonly clauseKind: 'distinct';
+/** SQLite-specific index metadata retained for a future adapter. */
+interface SqliteIndexExtension extends SchemaDialectExtension<"sqlite"> {
+  readonly auto?: boolean;
 }
-declare function distinct(): DistinctClause;
-//#endregion
-//#region src/query/clauses/having.d.ts
-interface HavingClause<TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'having';
-  readonly condition: BooleanExpression<any>;
+/** MySQL-specific index algorithm, locking, and parser metadata. */
+interface MysqlIndexExtension extends SchemaDialectExtension<"mysql"> {
+  readonly algorithm?: "default" | "inplace" | "copy";
+  readonly lock?: "default" | "none" | "shared" | "exclusive";
+  readonly using?: "btree" | "hash" | "rtree";
+  readonly parser?: string;
+  readonly keyBlockSize?: number;
 }
-type HavingComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? HavingClause<InheritedMetadata<TCondition>> : never;
-type HavingValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
-declare function having<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & HavingValidation<TCondition>): HavingComposition<TCondition>;
+/** First-party and user-defined dialect extensions for indexes. */
+type IndexDialectExtension = PostgresIndexExtension | SqliteIndexExtension | MysqlIndexExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
+interface IndexOptions<TPredicate extends AnyExpression | undefined = AnyExpression | undefined, TExtension extends IndexDialectExtension | undefined = IndexDialectExtension | undefined> extends SchemaObjectNameOptions {
+  readonly unique?: boolean;
+  readonly where?: TPredicate;
+  /** Columns stored in the index payload but not used as key terms. */
+  readonly include?: readonly ColumnReference<string, any>[];
+  /** Typed engine-specific index options. */
+  readonly dialect?: TExtension;
+}
+type IndexTermExpression$2<TTerm> = TTerm extends OrderTerm<any> ? TTerm["expression"] : TTerm;
+type IsNullableIndexColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
+type IsEligibleColumn<TTerm> = IndexTermExpression$2<TTerm> extends (infer TExpression) ? TExpression extends ColumnReference<string, any> ? IsNullableIndexColumn<TExpression> extends true ? false : true : false : false;
+type AllEligibleColumns<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: IsEligibleColumn<TTerms[K]>; }[number] extends (infer TEligibility) ? false extends TEligibility ? true extends TEligibility ? boolean : false : true : false;
+type BooleanOption<TValue> = [Extract<TValue, true>] extends [never] ? false : [Exclude<TValue, true>] extends [never] ? true : boolean;
+type UniqueOption<TOptions> = "unique" extends keyof TOptions ? BooleanOption<TOptions["unique"]> : false;
+type PredicateOption<TOptions> = "where" extends keyof TOptions ? TOptions["where"] : undefined;
+type DialectOption<TOptions> = TOptions extends {
+  readonly dialect?: infer TDialect;
+} ? unknown extends TDialect ? IndexDialectExtension | undefined : TDialect : undefined;
+type PredicatePresence<TOptions> = [Exclude<PredicateOption<TOptions>, undefined>] extends [never] ? false : undefined extends PredicateOption<TOptions> ? boolean : true;
+type IsCandidateKey<TTerms extends readonly IndexTerm[], TOptions extends IndexOptions<any>> = UniqueOption<TOptions> extends (infer TUnique) ? PredicatePresence<TOptions> extends (infer THasPredicate) ? AllEligibleColumns<TTerms> extends (infer TEligible) ? TUnique extends false ? false : THasPredicate extends true ? false : TEligible extends false ? false : TUnique extends true ? THasPredicate extends false ? TEligible extends true ? true : boolean : boolean : boolean : false : false : false;
+/** Portable index metadata retained by a table and its aliases. */
+interface TableIndex<TTerms extends readonly IndexTerm[] = any, TOptions extends IndexOptions<any> = any> extends SchemaObjectIdentity {
+  readonly kind: "index";
+  readonly terms: TTerms;
+  readonly unique: UniqueOption<TOptions>;
+  readonly predicate: PredicateOption<TOptions>;
+  readonly includedColumns?: TOptions extends {
+    readonly include: infer TIncluded;
+  } ? TIncluded : undefined;
+  readonly dialect?: DialectOption<TOptions>;
+  readonly candidateKey: IsCandidateKey<TTerms, TOptions>;
+}
+/** The widened index shape accepted by source metadata records. */
+interface SourceIndex {
+  readonly kind: "index";
+  readonly terms: readonly IndexTerm[];
+  readonly unique: boolean;
+  readonly predicate: AnyExpression | undefined;
+  readonly includedColumns?: readonly ColumnReference<string, any>[];
+  readonly dialect?: IndexDialectExtension;
+  readonly candidateKey: boolean;
+}
+type SourceIndexesRecord = Readonly<Record<string, SourceIndex>>;
+/**
+ * Validate portable and dialect-owned index facts for one target adapter. Unsupported features are
+ * reported as data so a serializer can aggregate diagnostics instead of failing during traversal
+ * with an opaque exception.
+ */
+declare function validateIndexDialect(indexMetadata: SourceIndex, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
+type ValidIndexExpression<T> = T extends AnyExpression ? HasAggregate<T> extends true ? never : HasWindow<T> extends true ? never : HasSubquery<T> extends true ? never : unknown : never;
+type InvalidIndexTerms<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: TTerms[K] extends OrderTerm<any> ? TTerms[K] extends {
+  readonly nulls: "FIRST" | "LAST";
+} ? TTerms[K] : ValidIndexExpression<TTerms[K]["expression"]> extends never ? TTerms[K] : never : ValidIndexExpression<TTerms[K]> extends never ? TTerms[K] : never; }[number];
+type IndexTermsValidation<TTerms extends readonly IndexTerm[]> = [InvalidIndexTerms<TTerms>] extends [never] ? unknown : never;
+/** Declare a portable column or expression index. */
+declare function index<const TTerms extends readonly [IndexTerm, ...IndexTerm[]], const TOptions extends IndexOptions<any> = {}>(terms: TTerms & IndexTermsValidation<NoInfer<TTerms>>, options?: TOptions): TableIndex<TTerms, TOptions>;
 //#endregion
-//#region src/query/clauses/pagination.d.ts
-interface OffsetClause extends SelectClause<never> {
-  readonly clauseKind: 'offset';
-  readonly rows: number;
+//#region src/schema/alias.d.ts
+type SourceIndexes$1<T> = T extends {
+  readonly indexes: infer TIndexes extends SourceIndexesRecord;
+} ? TIndexes : {};
+type AliasIdentity<TBase, TAlias extends string> = {
+  readonly sourceKind: "alias";
+  readonly alias: TAlias;
+  readonly base: TBase;
+};
+type AliasedSource<TBase extends Source<any>, TAlias extends string> = Source<{
+  readonly identity: AliasIdentity<SourceIdentity<TBase>, TAlias>;
+  readonly row: SourceRow<TBase>;
+  readonly metadata: RequiresOuterMetadataOf<TBase> | CapabilityMetadataOf<TBase>;
+  readonly sqlTypes: SourceSqlTypeMap<TBase>;
+  readonly constraints: SourceConstraints<TBase>;
+}> & {
+  readonly alias: TAlias;
+  readonly base: TBase;
+  readonly columns: SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
+  readonly constraints: SourceConstraints<TBase>;
+  readonly indexes: SourceIndexes$1<TBase>;
+} & SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
+type QueryAliasIdentity<TAlias extends string> = {
+  readonly sourceKind: "query-alias";
+  readonly alias: TAlias;
+};
+type QuerySource<TRow extends object, TAlias extends string, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = Source<{
+  readonly identity: QueryAliasIdentity<TAlias>;
+  readonly row: TRow;
+  readonly metadata: TMetadata;
+  readonly sqlTypes: TSqlTypes;
+}> & {
+  readonly alias: TAlias;
+  readonly query: Query<{
+    readonly row: TRow;
+    readonly cardinality: any;
+    readonly metadata: TMetadata;
+    readonly sqlTypes: TSqlTypes;
+  }>;
+  readonly columns: SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
+} & SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
+declare function alias<TBase extends Source<any>, const TAlias extends string>(source: TBase, name: TAlias): AliasedSource<TBase, TAlias>;
+declare function alias<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): QuerySource<QueryRow<TQuery>, TAlias, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>>;
+type LateralIdentity<TAlias extends string> = {
+  readonly sourceKind: "lateral";
+  readonly alias: TAlias;
+};
+type LateralSource<TQuery extends AnyQuery, TAlias extends string> = Source<{
+  readonly identity: LateralIdentity<TAlias>;
+  readonly row: QueryRow<TQuery>;
+  readonly metadata: RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>;
+  readonly sqlTypes: QuerySqlTypeMap<TQuery>;
+}> & {
+  readonly alias: TAlias;
+  readonly query: TQuery;
+  readonly columns: SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
+} & SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
+/** Render a query as a LATERAL source whose outer requirements stay visible. */
+declare function lateral<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): LateralSource<TQuery, TAlias>;
+//#endregion
+//#region src/schema/constraints.d.ts
+declare const fieldConstraint: unique symbol;
+/** Application and SQL facts that a reusable source field may require. */
+interface FieldLikeOptions {
+  readonly output?: unknown;
+  readonly sqlType?: object;
+  readonly nullable?: boolean;
 }
-type AnyPaginationClause = OffsetClause | FetchClause;
-declare function offset(rows: number): OffsetClause;
-interface FetchClause<TRows extends number = number> extends SelectClause<never> {
-  readonly clauseKind: 'fetch';
-  readonly direction: 'FIRST' | 'NEXT';
-  readonly rows: TRows;
+/**
+ * A reusable source-field requirement combining application and SQL facts. Omitted facts impose no
+ * constraint; `nullable: false` requires a non-null selected value.
+ */
+interface FieldLike<TOptions extends FieldLikeOptions = FieldLikeOptions> {
+  readonly [fieldConstraint]: TOptions;
+}
+type FieldOptions<T> = T extends FieldLike<infer TOptions> ? TOptions : never;
+type RequiredOutput<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
+  readonly output: infer TOutput;
+} ? FieldOptions<T> extends {
+  readonly nullable: false;
+} ? NonNullable<TOutput> : TOutput : FieldOptions<T> extends {
+  readonly nullable: false;
+} ? {} : unknown : T;
+type RequiredSqlType<T> = T extends FieldLike<any> ? FieldOptions<T> extends {
+  readonly sqlType: infer TSqlType;
+} ? (AnySqlType & TSqlType) | SqlUnknown : AnySqlType : AnySqlType;
+type RequiredColumn<TField extends string, TRequirement, TIdentity> = ColumnReference<TField, ResultMeta<RequiredOutput<TRequirement>, TIdentity, RequiredSqlType<TRequirement>> | RequiresSourceMeta<TIdentity> | ExpressionMeta<ColumnDependency<TIdentity, TField>>>;
+type RequiredColumns<TShape extends object, TIdentity> = { readonly [K in keyof TShape]-?: K extends string ? RequiredColumn<K, TShape[K], TIdentity> : never; };
+/**
+ * A source containing at least the requested application and SQL fields. Additional fields and the
+ * concrete source identity are preserved by generic functions that accept this lower-bound
+ * constraint.
+ */
+interface SourceLike<TShape extends object> extends Fragment<any> {
+  readonly sourceKind: SourceKind;
+  readonly [sourceIdentity]: unknown;
+  readonly reference: Fragment<never>;
+  readonly columns: RequiredColumns<TShape, this[typeof sourceIdentity]>;
+}
+/** The physical-table form of the lower-bound {@link SourceLike} constraint. */
+interface TableLike<TShape extends object> extends SourceLike<TShape> {
+  readonly tableName: string;
+  readonly definitions: object;
+  readonly sqlNames: Readonly<Record<string, string>>;
+}
+/** Standard SQL referential action retained on a foreign-key constraint. */
+type ReferentialAction = "no-action" | "restrict" | "cascade" | "set-null" | "set-default";
+/** Standard SQL match mode for a composite foreign key. */
+type ForeignKeyMatch = "simple" | "full" | "partial";
+/** Deferrability timing for a foreign-key or key constraint. */
+type ConstraintTiming = "immediate" | "deferred";
+/** PostgreSQL-only constraint options retained for a schema adapter. */
+interface PostgresConstraintExtension extends SchemaDialectExtension<"postgresql"> {
+  /** PostgreSQL `NOT VALID` validation state for a constraint. */
+  readonly notValid?: boolean;
+}
+/** SQLite-only table-constraint options. */
+interface SqliteConstraintExtension extends SchemaDialectExtension<"sqlite"> {
+  /** SQLite conflict policy attached to a table constraint. */
+  readonly onConflict?: "rollback" | "abort" | "fail" | "ignore" | "replace";
+}
+/** MySQL-only constraint options. */
+interface MysqlConstraintExtension extends SchemaDialectExtension<"mysql"> {
+  /** MySQL 8 constraint enforcement state. */
+  readonly enforced?: boolean;
+}
+/** First-party and user-defined dialect extensions for constraints. */
+type ConstraintDialectExtension = PostgresConstraintExtension | SqliteConstraintExtension | MysqlConstraintExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
+/** Shared physical-name and dialect-extension options for constraints. */
+interface ConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends SchemaObjectNameOptions {
+  /** Engine-specific metadata owned by a future schema adapter. */
+  readonly dialect?: TExtension;
+}
+/** Options for primary-key and candidate-key declarations. */
+interface KeyConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Whether the key can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable key. */
+  readonly initially?: ConstraintTiming;
+}
+/** Options for a database unique constraint, including nullable columns. */
+interface UniqueConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /**
+   * SQL NULL comparison semantics. `distinct` is the common default in which multiple NULL values
+   * do not conflict; `not-distinct` permits at most one.
+   */
+  readonly nulls?: UniqueNullSemantics;
+  /** Whether the constraint can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable constraint. */
+  readonly initially?: ConstraintTiming;
+}
+/** Explicit NULL behavior for a database uniqueness rule. */
+type UniqueNullSemantics = "distinct" | "not-distinct";
+/** Options for a table check constraint. */
+interface CheckConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Whether the check can be deferred by a supporting dialect. */
+  readonly deferrable?: boolean;
+  /** Initial enforcement timing for a deferrable check. */
+  readonly initially?: ConstraintTiming;
+}
+/** Dialect tag and parameter-free SQL needed to reconstruct a catalog check. */
+interface CatalogCheckSql<TDialect extends SchemaDialectName = SchemaDialectName> {
+  /** Catalog dialect that supplied the check expression. */
+  readonly dialect: TDialect;
+  /** Opaque SQL text recovered from the catalog. */
+  readonly sql: string;
+}
+/** Options for a foreign-key declaration. */
+interface ForeignKeyOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  readonly onUpdate?: ReferentialAction;
+  readonly onDelete?: ReferentialAction;
+  readonly match?: ForeignKeyMatch;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** A schema constraint whose columns form a relational key. */
+interface KeyConstraint<TKind extends "primary-key" | "unique" = "primary-key" | "unique", TColumns extends readonly ColumnReference<string, any>[] = readonly ColumnReference<string, any>[]> extends SchemaObjectIdentity {
+  readonly kind: TKind;
+  readonly columns: TColumns;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
+}
+/** A referenced table and exact candidate-key column tuple. */
+interface ForeignKeyTarget<TTable extends TableLike<any> = TableLike<any>, TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[]> {
+  readonly table: TTable;
+  readonly columns: TColumns;
+}
+type ForeignKeyTargetInput<TTarget extends ForeignKeyTarget = ForeignKeyTarget> = TTarget | (() => TTarget);
+/** A foreign key from local columns to a direct or lazily resolved target. */
+interface ForeignKeyConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TTarget extends ForeignKeyTargetInput = ForeignKeyTargetInput> extends SchemaObjectIdentity {
+  readonly kind: "foreign-key";
+  readonly columns: TColumns;
+  readonly target: TTarget;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly onUpdate?: ReferentialAction;
+  readonly onDelete?: ReferentialAction;
+  readonly match?: ForeignKeyMatch;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
 }
-declare function fetchFirst<const TRows extends number>(rows: TRows): FetchClause<TRows>;
-declare function fetchNext<const TRows extends number>(rows: TRows): FetchClause<TRows>;
-//#endregion
-//#region src/query/clauses/row-lock.d.ts
-interface RowLockOptions<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> {
-  readonly mode?: TMode;
-  readonly wait?: TWait;
-  readonly waitPolicy?: TWait;
+/** Database uniqueness that deliberately does not prove a candidate key. */
+interface UniqueConstraint<TColumns extends readonly AnyKeyColumn[] = readonly AnyKeyColumn[], TNulls extends UniqueNullSemantics = UniqueNullSemantics> extends SchemaObjectIdentity {
+  readonly kind: "unique-constraint";
+  readonly columns: TColumns;
+  readonly nulls: TNulls;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
 }
-interface RowLockClause<TMode extends RowLockMode = RowLockMode, TWait extends RowLockWaitPolicy = RowLockWaitPolicy> extends SelectClause<RequiresCapabilityMeta<'row-locking'>> {
-  readonly clauseKind: 'row-lock';
-  readonly mode: TMode;
-  readonly wait: TWait;
+/** A table-scoped boolean invariant. */
+interface CheckConstraint<TExpression extends AnyExpression = AnyExpression> extends SchemaObjectIdentity {
+  readonly kind: "check";
+  readonly expression: TExpression;
+  readonly physicalName?: string;
+  readonly dialect?: ConstraintDialectExtension;
+  readonly deferrable?: boolean;
+  readonly initially?: ConstraintTiming;
 }
-declare function rowLock(): RowLockClause<'update', 'default'>;
-declare function rowLock<TMode extends RowLockMode>(mode: TMode): RowLockClause<TMode, 'default'>;
-declare function rowLock<TMode extends RowLockMode, TWait extends RowLockWaitPolicy>(mode: TMode, wait: TWait): RowLockClause<TMode, TWait>;
-declare function rowLock(options: RowLockOptions): RowLockClause;
-//#endregion
-//#region src/query/clauses/where.d.ts
-interface WhereClause<TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'where';
-  readonly condition: BooleanExpression<any>;
+/**
+ * Opaque catalog SQL whose check-constraint origin proves a boolean SQL semantic type. The
+ * expression remains dialect-tagged and parameter-free.
+ */
+interface CatalogCheckExpression<TDialect extends SchemaDialectName = SchemaDialectName> extends SchemaExpression<ResultMeta<boolean, never, SqlBoolean> | ExpressionMeta<never>, "unsafe"> {
+  readonly schemaSqlDialect: TDialect;
+  readonly schemaSql: string;
 }
-type WhereComposition<TCondition extends BooleanExpression<any> | Omit$1> = TCondition extends Omit$1 ? Omit$1 : TCondition extends BooleanExpression<any> ? WhereClause<InheritedMetadata<TCondition>> : never;
-type WhereValidation<TCondition> = TCondition extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>;
-declare function where<TCondition extends BooleanExpression<any> | Omit$1>(condition: TCondition & WhereValidation<TCondition>): WhereComposition<TCondition>;
-//#endregion
-//#region src/query/omit.d.ts
-/** An explicit placeholder for a safely omitted SELECT clause or projection field. */
-declare const omit: unique symbol;
-type Omit$1 = typeof omit;
-type OmittableSelectClause = DistinctClause | HavingClause<any> | OrderByClause<any> | OffsetClause | FetchClause | RowLockClause | WhereClause<any>;
-type SelectPart = AnySelectClause | Omit$1;
-type PresentClauses<TParts extends readonly SelectPart[]> = { readonly [TIndex in keyof TParts]: Exclude<TParts[TIndex], Omit$1>; };
-type InvalidOmittedClauses<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? Exclude<TParts[TIndex], Omit$1> extends OmittableSelectClause ? never : Exclude<TParts[TIndex], Omit$1> : never; }[number];
-type OmissionValidation<TParts extends readonly SelectPart[]> = [InvalidOmittedClauses<TParts>] extends [never] ? unknown : QueryTypeValidation<'invalid-omission', 'select.omit', 'Use omit only for a conditional SELECT clause or projection field.', InvalidOmittedClauses<TParts>>;
-//#endregion
-//#region src/expressions/operators/logic.d.ts
-type BooleanOperand = BooleanExpression<any> | Omit$1;
-type PresentConditions<TConditions extends readonly BooleanOperand[]> = Exclude<TConditions[number], Omit$1>;
-type BooleanComposition<TConditions extends readonly BooleanOperand[]> = [PresentConditions<TConditions>] extends [never] ? Omit$1 : ResultExpression<{
-  readonly output: boolean;
-  readonly children: PresentConditions<TConditions>;
-  readonly kind: 'operator';
-  readonly nullableFrom: NullabilityOf<PresentConditions<TConditions>>;
-  readonly sqlType: SqlBoolean;
-}> | (Omit$1 extends TConditions[number] ? Omit$1 : never);
-type BooleanConditionsValidation<TConditions extends readonly unknown[]> = TConditions extends readonly [infer THead, ...infer TTail] ? (THead extends Omit$1 ? unknown : SqlCapabilityValidation<ExpressionSqlType<THead>, SqlBoolean>) & BooleanConditionsValidation<TTail> : unknown;
-declare function and<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
-declare function or<const TConditions extends readonly BooleanOperand[]>(...conditions: TConditions & BooleanConditionsValidation<TConditions>): BooleanComposition<TConditions>;
-declare function not<TCondition extends BooleanExpression<any>>(condition: TCondition & SqlCapabilityValidation<ExpressionSqlType<TCondition>, SqlBoolean>): ResultExpression<{
-  readonly output: boolean;
-  readonly children: TCondition;
-  readonly kind: "operator";
-  readonly nullableFrom: NullabilityOf<TCondition>;
-  readonly sqlType: SqlBoolean;
-}>;
-//#endregion
-//#region src/schema/alias.d.ts
-type SourceIndexes$1<T> = T extends {
-  readonly indexes: infer TIndexes extends SourceIndexesRecord;
-} ? TIndexes : {};
-type AliasIdentity<TBase, TAlias extends string> = {
-  readonly sourceKind: 'alias';
-  readonly alias: TAlias;
-  readonly base: TBase;
-};
-type AliasedSource<TBase extends Source<any>, TAlias extends string> = Source<{
-  readonly identity: AliasIdentity<SourceIdentity<TBase>, TAlias>;
-  readonly row: SourceRow<TBase>;
-  readonly metadata: RequiresOuterMetadataOf<TBase> | CapabilityMetadataOf<TBase>;
-  readonly sqlTypes: SourceSqlTypeMap<TBase>;
-  readonly constraints: SourceConstraints<TBase>;
-}> & {
-  readonly alias: TAlias;
-  readonly base: TBase;
-  readonly columns: SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
-  readonly constraints: SourceConstraints<TBase>;
-  readonly indexes: SourceIndexes$1<TBase>;
-} & SourceColumns<SourceRow<TBase>, AliasIdentity<SourceIdentity<TBase>, TAlias>, SourceSqlTypeMap<TBase>>;
-type QueryAliasIdentity<TAlias extends string> = {
-  readonly sourceKind: 'query-alias';
-  readonly alias: TAlias;
-};
-type QuerySource<TRow extends object, TAlias extends string, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = Source<{
-  readonly identity: QueryAliasIdentity<TAlias>;
-  readonly row: TRow;
-  readonly metadata: TMetadata;
-  readonly sqlTypes: TSqlTypes;
-}> & {
-  readonly alias: TAlias;
-  readonly query: Query$1<{
-    readonly row: TRow;
-    readonly cardinality: any;
-    readonly metadata: TMetadata;
-    readonly sqlTypes: TSqlTypes;
-  }>;
-  readonly columns: SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
-} & SourceColumns<TRow, QueryAliasIdentity<TAlias>, TSqlTypes>;
-declare function alias<TBase extends Source<any>, const TAlias extends string>(source: TBase, name: TAlias): AliasedSource<TBase, TAlias>;
-declare function alias<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): QuerySource<QueryRow<TQuery>, TAlias, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>>;
-type LateralIdentity<TAlias extends string> = {
-  readonly sourceKind: 'lateral';
-  readonly alias: TAlias;
-};
-type LateralSource<TQuery extends AnyQuery, TAlias extends string> = Source<{
-  readonly identity: LateralIdentity<TAlias>;
-  readonly row: QueryRow<TQuery>;
-  readonly metadata: RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>;
-  readonly sqlTypes: QuerySqlTypeMap<TQuery>;
-}> & {
-  readonly alias: TAlias;
-  readonly query: TQuery;
-  readonly columns: SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
-} & SourceColumns<QueryRow<TQuery>, LateralIdentity<TAlias>, QuerySqlTypeMap<TQuery>>;
-/** Render a query as a LATERAL source whose outer requirements stay visible. */
-declare function lateral<TQuery extends AnyQuery, const TAlias extends string>(query: TQuery, name: TAlias): LateralSource<TQuery, TAlias>;
+/** Structured schema metadata carried by sources that declare constraints. */
+type SourceConstraint = KeyConstraint | UniqueConstraint | ForeignKeyConstraint | CheckConstraint;
+/** Named schema constraints attached to a source. */
+type SourceConstraintsRecord = Readonly<Record<string, SourceConstraint>>;
+/**
+ * Validate one constraint against a schema adapter dialect. This is kept separate from construction
+ * because the same declaration can be inspected for more than one target dialect before a
+ * serializer is selected.
+ */
+declare function validateConstraintDialect(constraint: SourceConstraint, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
+type AnyKeyColumn = ColumnReference<string, any>;
+type ColumnSource<TColumn> = DependenciesOf<TColumn> extends ColumnDependency<infer TSource, string> ? TSource : never;
+type IsNullableKeyColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
+type InvalidKeyColumn<TColumn, TSource> = TColumn extends AnyKeyColumn ? IsNullableKeyColumn<TColumn> extends true ? TColumn : DependenciesOf<TColumn> extends ColumnDependency<TSource, string> ? never : TColumn : TColumn;
+type KeyColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: InvalidKeyColumn<TColumns[K], ColumnSource<TColumns[0]>>; }[number]] extends [never] ? unknown : never;
+type SameSourceColumnsValidation<TColumns extends readonly AnyKeyColumn[]> = [{ [K in keyof TColumns]: TColumns[K] extends AnyKeyColumn ? DependenciesOf<TColumns[K]> extends ColumnDependency<ColumnSource<TColumns[0]>, string> ? never : TColumns[K] : TColumns[K]; }[number]] extends [never] ? unknown : never;
+type SameSqlDomain<TLeft, TRight> = SqlTypeOf<TLeft> extends (infer TLeftSql) ? SqlTypeOf<TRight> extends (infer TRightSql) ? TLeftSql extends SqlUnknown ? false : TRightSql extends SqlUnknown ? false : TLeftSql extends AnySqlType ? TRightSql extends AnySqlType ? string extends TLeftSql["sqlType"] ? false : string extends TRightSql["sqlType"] ? false : [TLeftSql["sqlType"]] extends [TRightSql["sqlType"]] ? [TRightSql["sqlType"]] extends [TLeftSql["sqlType"]] ? true : false : false : false : false : false : false;
+type ForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? SameSqlDomain<TLocalHead, TTargetHead> extends true ? ForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
+type IsUnresolvedSqlDomain<TSqlType> = TSqlType extends SqlUnknown ? true : TSqlType extends AnySqlType ? string extends TSqlType["sqlType"] ? true : false : true;
+type CatalogSqlDomainCompatible<TLeft, TRight> = true extends IsUnresolvedSqlDomain<SqlTypeOf<TLeft>> | IsUnresolvedSqlDomain<SqlTypeOf<TRight>> ? true : SameSqlDomain<TLeft, TRight>;
+type CatalogForeignKeyColumnsValidation<TLocal extends readonly AnyKeyColumn[], TTarget extends readonly AnyKeyColumn[]> = TLocal extends readonly [infer TLocalHead, ...infer TLocalTail] ? TTarget extends readonly [infer TTargetHead, ...infer TTargetTail] ? TLocalHead extends AnyKeyColumn ? TTargetHead extends AnyKeyColumn ? CatalogSqlDomainCompatible<TLocalHead, TTargetHead> extends true ? CatalogForeignKeyColumnsValidation<Extract<TLocalTail, readonly AnyKeyColumn[]>, Extract<TTargetTail, readonly AnyKeyColumn[]>> : never : never : never : never : TTarget extends readonly [] ? unknown : never;
+type CheckExpressionValidation<TExpression> = [SqlTypeOf<TExpression>] extends [never] ? never : SqlTypeOf<TExpression> extends SqlBoolean ? unknown : never;
+/** Declare a primary key, including a composite primary key. */
+declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<"primary-key", TColumns>;
+declare function primaryKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<"primary-key", TColumns>;
+/** Declare a non-null unique key, including a composite unique key. */
+declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<"unique", TColumns>;
+declare function unique<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends KeyConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & KeyColumnsValidation<NoInfer<TColumns>>): KeyConstraint<"unique", TColumns>;
+/**
+ * Describe database uniqueness without claiming that the columns determine a row. Nullable columns
+ * are accepted, and the NULL behavior is explicit in the returned metadata. Use {@link unique} when
+ * a type-level key proof is intended.
+ */
+declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(...columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, "distinct">;
+declare function uniqueConstraint<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TOptions extends UniqueConstraintOptions>(...columnsAndOptions: [...TColumns, TOptions] & SameSourceColumnsValidation<NoInfer<TColumns>>): UniqueConstraint<TColumns, TOptions extends {
+  readonly nulls: infer TNulls extends UniqueNullSemantics;
+} ? TNulls : "distinct">;
+/** Pair a table with the exact columns targeted by a foreign key. */
+declare function references<TTable extends TableLike<any>, const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]]>(table: TTable, ...columns: TColumns): ForeignKeyTarget<TTable, TColumns>;
+type ResolvedTarget$1<T> = T extends (() => infer TResolved) ? TResolved : T;
+/** Declare a single-column or composite foreign key. */
+declare function foreignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? ForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
+/**
+ * Reconstruct a foreign key proved by database catalog metadata.
+ *
+ * @remarks
+ *   Use this helper for generated or introspection-owned declarations when one or both native SQL
+ *   domains are unresolved. It accepts unresolved domains, but still rejects known domain
+ *   mismatches, unequal tuple arity, and local columns from different sources. The enclosing
+ *   `table()` declaration continues to verify target-column ownership and candidate-key metadata.
+ *   Resolved targets also receive runtime shape, ownership, and arity checks. The returned value
+ *   serializes as an ordinary foreign-key constraint.
+ */
+declare function catalogForeignKey<const TColumns extends readonly [AnyKeyColumn, ...AnyKeyColumn[]], const TTarget extends ForeignKeyTargetInput, const TOptions extends ForeignKeyOptions = {}>(columns: TColumns & SameSourceColumnsValidation<NoInfer<TColumns>>, target: TTarget & (ResolvedTarget$1<TTarget> extends ForeignKeyTarget<any, infer TTargetColumns> ? CatalogForeignKeyColumnsValidation<TColumns, TTargetColumns> : never), options?: TOptions): ForeignKeyConstraint<TColumns, TTarget>;
+/** Declare a boolean table invariant. */
+declare function check<const TExpression extends Expression<any, any>, const TOptions extends CheckConstraintOptions = {}>(expression: TExpression & CheckExpressionValidation<TExpression>, options?: TOptions): CheckConstraint<TExpression>;
+/**
+ * Reconstruct a boolean check from opaque SQL recovered from a database catalog.
+ *
+ * @remarks
+ *   This helper records catalog origin as a narrow type-level proof. It gives the opaque expression
+ *   the {@link SqlBoolean} semantic type without changing the ordinary {@link check} contract. Qubu
+ *   does not parse or infer dependencies from the SQL. It preserves the text apart from normalizing
+ *   line endings and retains the dialect tag in serialized schema metadata.
+ */
+declare function catalogCheck<const TDialect extends SchemaDialectName, const TOptions extends CheckConstraintOptions = {}>(input: CatalogCheckSql<TDialect>, options?: TOptions): CheckConstraint<CatalogCheckExpression<TDialect>>;
 //#endregion
 //#region src/schema/registry.d.ts
 /** The first naming-policy version used by schema metadata. */
@@ -2885,8 +2958,8 @@ interface SchemaNamingPolicy {
 /**
  * The built-in naming policy for schema-generated physical names.
  *
- * Explicit names supplied to `table()` remain unchanged. The policy is used
- * by tooling when it needs a physical name for a logical table ID.
+ * Explicit names supplied to `table()` remain unchanged. The policy is used by tooling when it
+ * needs a physical name for a logical table ID.
  */
 declare const defaultSchemaNamingPolicy: SchemaNamingPolicy;
 /** A table record accepted by {@link schema}. */
@@ -2913,7 +2986,7 @@ type SchemaTableRegistry<TTables extends SchemaTableRecord> = { readonly [K in k
 type SchemaTableNames<TTables extends SchemaTableRecord> = Readonly<{ [K in keyof TTables & string]: string; }>;
 /** The root model returned by {@link schema}. */
 interface Schema<TTables extends SchemaTableRecord = SchemaTableRecord> {
-  readonly schemaKind: 'schema';
+  readonly schemaKind: "schema";
   /** Tables keyed by stable logical ID. */
   readonly tables: Readonly<TTables>;
   /** Explicit registry entries with logical and physical identity separated. */
@@ -2927,7 +3000,7 @@ interface Schema<TTables extends SchemaTableRecord = SchemaTableRecord> {
 }
 /** A structured validation finding produced while constructing a schema. */
 interface SchemaDiagnostic {
-  readonly code: 'invalid-table-id' | 'duplicate-table-id' | 'duplicate-physical-name' | 'invalid-namespace' | 'generated-name-collision';
+  readonly code: "invalid-table-id" | "duplicate-table-id" | "duplicate-physical-name" | "invalid-namespace" | "generated-name-collision";
   readonly message: string;
   /** Location of the invalid or conflicting declaration. */
   readonly path: readonly (string | number)[];
@@ -2946,18 +3019,18 @@ type EntriesToTables<TEntries extends readonly SchemaTableInput[]> = { readonly
 /**
  * Create an immutable root registry keyed by stable logical table IDs.
  *
- * The input keys are logical IDs. Each table keeps the physical name already
- * used by query rendering, so registering a table does not change its row
- * inference, source identity, or generated SQL. The optional namespace is
- * metadata for schema tooling and is not added to ordinary query rendering.
+ * The input keys are logical IDs. Each table keeps the physical name already used by query
+ * rendering, so registering a table does not change its row inference, source identity, or
+ * generated SQL. The optional namespace is metadata for schema tooling and is not added to ordinary
+ * query rendering.
  *
- * @throws {@link SchemaValidationError} when IDs, physical names, namespaces,
- * or generated names collide or are invalid.
+ * @throws {@link SchemaValidationError} When IDs, physical names, namespaces, or generated names
+ *   collide or are invalid.
  */
 declare function schema<const TTables extends SchemaTableRecord>(tables: TTables, options?: SchemaOptions): Schema<TTables>;
 /**
- * Tuple input is useful for integrations that need duplicate-ID diagnostics
- * before converting declarations into an object record.
+ * Tuple input is useful for integrations that need duplicate-ID diagnostics before converting
+ * declarations into an object record.
  */
 declare function schema<const TEntries extends readonly SchemaTableInput[]>(tables: TEntries, options?: SchemaOptions): Schema<EntriesToTables<TEntries>>;
 /** Generate a v1 physical name for a logical table ID. */
@@ -2965,9 +3038,9 @@ declare function generatedTableName(logicalId: string, namingPolicy?: SchemaNami
 //#endregion
 //#region src/schema/expressions.d.ts
 /** SQL declaration context in which a schema expression will be emitted. */
-type SchemaExpressionMode = 'default' | 'generated' | 'check' | 'index';
+type SchemaExpressionMode = "default" | "generated" | "check" | "index";
 /** Stable error categories for schema-expression validation failures. */
-type SchemaExpressionErrorCode = 'not-deterministic' | 'unsupported-expression' | 'parameter' | 'unsupported-value' | 'column-not-allowed' | 'dialect-mismatch' | 'invalid-literal';
+type SchemaExpressionErrorCode = "not-deterministic" | "unsupported-expression" | "parameter" | "unsupported-value" | "column-not-allowed" | "dialect-mismatch" | "invalid-literal";
 /** Error raised before a schema expression can become persisted SQL. */
 declare class SchemaExpressionError extends TypeError {
   readonly code: SchemaExpressionErrorCode;
@@ -2975,9 +3048,9 @@ declare class SchemaExpressionError extends TypeError {
   constructor(code: SchemaExpressionErrorCode, message: string, mode?: SchemaExpressionMode);
 }
 /**
- * Restricted rendering surface made available to explicit schema extensions.
- * `parameter()` is retained for structural compatibility with query
- * renderers, but always throws; use `literal()` for deterministic values.
+ * Restricted rendering surface made available to explicit schema extensions. `parameter()` is
+ * retained for structural compatibility with query renderers, but always throws; use `literal()`
+ * for deterministic values.
  */
 interface SchemaRenderContext extends RenderContext {
   readonly schemaMode: SchemaExpressionMode;
@@ -2999,30 +3072,29 @@ type SchemaExpressionInput<TExpression extends AnyExpression> = TExpression exte
   readonly __requires_deterministic_schema_expression__: never;
 };
 /** A dialect-tagged raw SQL expression for syntax Qubu does not model. */
-interface UnsafeSchemaSqlExpression extends SchemaExpression<never, 'unsafe'> {
+interface UnsafeSchemaSqlExpression extends SchemaExpression<never, "unsafe"> {
   readonly schemaSqlDialect: string;
   readonly schemaSql: string;
 }
 /**
- * Normalize only line endings. Whitespace, quoting, and every other byte of
- * a raw schema expression remain under the extension author's control.
+ * Normalize only line endings. Whitespace, quoting, and every other byte of a raw schema expression
+ * remain under the extension author's control.
  */
 declare function normalizeSchemaSql(sql: string): string;
 /**
- * Explicitly opt an audited expression into deterministic schema rendering.
- * The wrapper does not rewrite the renderer; it records the author's promise
- * so schema consumers can reject ordinary query extensions by default.
+ * Explicitly opt an audited expression into deterministic schema rendering. The wrapper does not
+ * rewrite the renderer; it records the author's promise so schema consumers can reject ordinary
+ * query extensions by default.
  */
-declare function schemaExpression<TExpression extends AnyExpression>(expression: TExpression): SchemaExpression<MetadataOf<TExpression>, TExpression['expressionKind']>;
+declare function schemaExpression<TExpression extends AnyExpression>(expression: TExpression): SchemaExpression<MetadataOf<TExpression>, TExpression["expressionKind"]>;
 /**
- * Define an extension with the restricted schema context. This is the typed
- * alternative to {@link unsafeSchemaSql} for deterministic custom syntax.
+ * Define an extension with the restricted schema context. This is the typed alternative to
+ * {@link unsafeSchemaSql} for deterministic custom syntax.
  */
-declare function defineSchemaExpression<TMetadata = never, TKind extends ExpressionKind = 'function'>(kind: TKind, render: (context: SchemaRenderContext) => void): SchemaExpression<TMetadata, TKind>;
+declare function defineSchemaExpression<TMetadata = never, TKind extends ExpressionKind = "function">(kind: TKind, render: (context: SchemaRenderContext) => void): SchemaExpression<TMetadata, TKind>;
 /**
- * Create a dialect-specific raw schema expression. The SQL is parameter-free
- * by contract and is preserved exactly apart from CRLF/CR line-ending
- * normalization.
+ * Create a dialect-specific raw schema expression. The SQL is parameter-free by contract and is
+ * preserved exactly apart from CRLF/CR line-ending normalization.
  */
 declare function unsafeSchemaSql(dialect: string, sql: string): UnsafeSchemaSqlExpression;
 declare function unsafeSchemaSql(options: {
@@ -3041,9 +3113,8 @@ declare function renderSchemaSql<TExpression extends AnyExpression>(expression:
 /**
  * Schema-only behavior layered onto a query dialect.
  *
- * The query policy is deliberately not repeated here: identifier quoting,
- * placeholders, JSON, casts, and capability identity all come from the
- * enclosing {@link SchemaDialect}.
+ * The query policy is deliberately not repeated here: identifier quoting, placeholders, JSON,
+ * casts, and capability identity all come from the enclosing {@link SchemaDialect}.
  */
 interface SchemaDialectHooks {
   /** Version of this dialect's schema metadata extension contract. */
@@ -3062,16 +3133,15 @@ interface SchemaDialectHooks {
 /**
  * A schema dialect is a strict capability superset of a query dialect.
  *
- * A schema dialect must be created with {@link createSchemaDialect}; that
- * helper preserves the exact query rendering object and adds only schema
- * behavior and snapshot metadata.
+ * A schema dialect must be created with {@link createSchemaDialect}; that helper preserves the exact
+ * query rendering object and adds only schema behavior and snapshot metadata.
  */
 interface SchemaDialect<TCapabilities extends DialectCapability = DialectCapability> extends Dialect<TCapabilities> {
   readonly schema: SchemaDialectHooks;
 }
 /**
- * Add schema behavior to an existing query dialect without rebuilding any of
- * its identifier, literal, placeholder, JSON, cast, or capability policies.
+ * Add schema behavior to an existing query dialect without rebuilding any of its identifier,
+ * literal, placeholder, JSON, cast, or capability policies.
  */
 declare function createSchemaDialect<const TCapabilities extends DialectCapability = DialectCapability>(queryDialect: Dialect<TCapabilities>, schema: SchemaDialectHooks): SchemaDialect<TCapabilities>;
 //#endregion
@@ -3079,8 +3149,8 @@ declare function createSchemaDialect<const TCapabilities extends DialectCapabili
 /**
  * Return every known source column as a named projection object.
  *
- * The result can be passed directly to `select()` or spread into a larger
- * projection, such as `{ ...all(users), displayName: upper(users.name) }`.
+ * The result can be passed directly to `select()` or spread into a larger projection, such as `{
+ * ...all(users), displayName: upper(users.name) }`.
  */
 declare function all<TSource extends AnySource>(source: TSource): SourceColumns<SourceRow<TSource>, SourceIdentity<TSource>, SourceSqlTypeMap<TSource>>;
 type SelectionObject = Record<string, AnyExpression | Omit$1>;
@@ -3098,17 +3168,26 @@ type SelectionMetadata<TSelection> = InheritedMetadata<SelectionItems<TSelection
 /** SQL result domains retained for each named projection field. */
 type SelectionSqlTypes<TSelection, TRow extends object = SelectionOutput<TSelection>> = { readonly [K in keyof TRow]: K extends keyof TSelection ? SqlTypeOf<TSelection[K]> : SqlUnknown; };
 //#endregion
+//#region src/query/clauses/from.d.ts
+interface FromClause<TSources extends readonly AnySource[] = readonly AnySource[], TMetadata = RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>> extends SelectClause<TMetadata> {
+  readonly clauseKind: "from";
+  readonly sources: TSources;
+}
+declare function from<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): FromClause<TSources, RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>>;
+type FromSource<T> = T extends FromClause<infer TSources> ? TSources[number] extends (infer TSource) ? TSource extends Source<any> ? [SourceProvision<TSource>] extends [never] ? never : TSource : never : never : never;
+type FromScope<T> = T extends FromClause<infer TSources> ? ProvidedSourceIdentity<TSources[number]> : never;
+//#endregion
 //#region src/query/clauses/group-by.d.ts
 interface GroupByClause<TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'group-by';
+  readonly clauseKind: "group-by";
   readonly expressions: readonly AnyExpression[];
 }
 declare function groupBy<const TExpressions extends readonly AnyExpression[]>(...expressions: TExpressions): GroupByClause<GroupingMeta<TExpressions[number], ColumnGroupingDependencies<TExpressions[number]>> | InheritedMetadata<TExpressions[number]>>;
 //#endregion
 //#region src/query/clauses/joins.d.ts
-type JoinType = 'INNER' | 'LEFT' | 'RIGHT' | 'FULL' | 'CROSS' | 'NATURAL';
+type JoinType = "INNER" | "LEFT" | "RIGHT" | "FULL" | "CROSS" | "NATURAL";
 interface JoinClause<TSource extends AnySource = AnySource, TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'join';
+  readonly clauseKind: "join";
   readonly joinType: JoinType;
   readonly source: TSource;
   readonly condition?: BooleanExpression<any>;
@@ -3136,22 +3215,13 @@ declare function fullJoin<TSource extends AnySource, TCondition extends BooleanE
 declare function crossJoin<TSource extends AnySource>(source: TSource): JoinClause<TSource, RequiresOuterMetadataOf<TSource> | CapabilityMetadataOf<TSource>>;
 declare function naturalJoin<TSource extends AnySource>(source: TSource): JoinClause<TSource, RequiresOuterMetadataOf<TSource> | CapabilityMetadataOf<TSource>>;
 //#endregion
-//#region src/query/clauses/from.d.ts
-interface FromClause<TSources extends readonly AnySource[] = readonly AnySource[], TMetadata = RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'from';
-  readonly sources: TSources;
-}
-declare function from<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): FromClause<TSources, RequiresOuterMetadataOf<TSources[number]> | CapabilityMetadataOf<TSources[number]>>;
-type FromSource<T> = T extends FromClause<infer TSources> ? TSources[number] extends (infer TSource) ? TSource extends Source<any> ? [SourceProvision<TSource>] extends [never] ? never : TSource : never : never : never;
-type FromScope<T> = T extends FromClause<infer TSources> ? ProvidedSourceIdentity<TSources[number]> : never;
-//#endregion
 //#region src/query/set.d.ts
-type SetOperator = 'UNION' | 'UNION ALL' | 'INTERSECT' | 'EXCEPT';
+type SetOperator = "UNION" | "UNION ALL" | "INTERSECT" | "EXCEPT";
 interface SetQuery<TConfig extends QueryConfig = {}> extends Query<TConfig> {
-  readonly queryKind: 'set';
+  readonly queryKind: "set";
 }
 type SetSqlCompatibilityFailures<TLeft, TRight> = { [K in keyof QuerySqlTypeMap<TLeft>]: K extends keyof QuerySqlTypeMap<TRight> ? SqlEqualityCompatible<QuerySqlTypeMap<TLeft>[K], QuerySqlTypeMap<TRight>[K]> extends true ? never : K : K; }[keyof QuerySqlTypeMap<TLeft>];
-type SetSqlValidation<TLeft, TRight> = [SetSqlCompatibilityFailures<TLeft, TRight>] extends [never] ? unknown : QueryTypeValidation<'incompatible-set-domain', 'set-operation.columns', 'Make corresponding set-operation fields use compatible SQL domains.', SetSqlCompatibilityFailures<TLeft, TRight>>;
+type SetSqlValidation<TLeft, TRight> = [SetSqlCompatibilityFailures<TLeft, TRight>] extends [never] ? unknown : QueryTypeValidation<"incompatible-set-domain", "set-operation.columns", "Make corresponding set-operation fields use compatible SQL domains.", SetSqlCompatibilityFailures<TLeft, TRight>>;
 declare function union<TLeft extends AnyQuery, TRight extends QueryWithRow<QueryRow<TLeft>>>(left: TLeft & SetSqlValidation<TLeft, TRight>, right: TRight): SetQuery<{
   readonly row: QueryRow<TLeft & SetSqlValidation<TLeft, TRight>>;
   readonly cardinality: any;
@@ -3179,7 +3249,7 @@ declare function except<TLeft extends AnyQuery, TRight extends QueryWithRow<Quer
 //#endregion
 //#region src/query/clauses/with.d.ts
 type CteIdentity<TName extends string> = {
-  readonly sourceKind: 'cte';
+  readonly sourceKind: "cte";
   readonly name: TName;
 };
 type CteSource<TName extends string, TRow extends object, TMetadata = never, TSqlTypes extends SourceSqlTypes<TRow> = UnknownSourceSqlTypes<TRow>> = Source<{
@@ -3189,7 +3259,7 @@ type CteSource<TName extends string, TRow extends object, TMetadata = never, TSq
   readonly sqlTypes: TSqlTypes;
 }> & {
   readonly cteName: TName;
-  readonly query: Query$1<{
+  readonly query: Query<{
     readonly row: TRow;
     readonly cardinality: any;
     readonly metadata: TMetadata;
@@ -3198,9 +3268,9 @@ type CteSource<TName extends string, TRow extends object, TMetadata = never, TSq
   readonly columns: SourceColumns<TRow, CteIdentity<TName>, TSqlTypes>;
 } & SourceColumns<TRow, CteIdentity<TName>, TSqlTypes>;
 type CteMetadata<TQuery extends AnyQuery> = RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>;
-type IsUnknown<T> = unknown extends T ? [keyof T] extends [never] ? true : false : false;
+type IsUnknown<T> = unknown extends T ? ([keyof T] extends [never] ? true : false) : false;
 type RecursiveMemberFieldFailures<TAnchor, TMember> = Exclude<keyof QueryRow<TAnchor>, keyof QueryRow<TMember>> | Exclude<keyof QueryRow<TMember>, keyof QueryRow<TAnchor>> | { [K in keyof QueryRow<TAnchor> & keyof QueryRow<TMember>]: [IsUnknown<QueryRow<TMember>[K]>] extends [true] ? never : [IsUnknown<QueryRow<TAnchor>[K]>] extends [true] ? never : [QueryRow<TMember>[K]] extends [QueryRow<TAnchor>[K]] ? never : K; }[keyof QueryRow<TAnchor> & keyof QueryRow<TMember>];
-type RecursiveMemberShapeValidation<TAnchor, TMember> = [RecursiveMemberFieldFailures<TAnchor, TMember>] extends [never] ? unknown : QueryTypeValidation<'incompatible-set-domain', 'recursive-cte.member', 'The recursive member must expose the anchor fields with compatible application types.', RecursiveMemberFieldFailures<TAnchor, TMember>>;
+type RecursiveMemberShapeValidation<TAnchor, TMember> = [RecursiveMemberFieldFailures<TAnchor, TMember>] extends [never] ? unknown : QueryTypeValidation<"incompatible-set-domain", "recursive-cte.member", "The recursive member must expose the anchor fields with compatible application types.", RecursiveMemberFieldFailures<TAnchor, TMember>>;
 type RecursiveMemberValidation<TAnchor, TMember> = RecursiveMemberShapeValidation<TAnchor, TMember> & SetSqlValidation<TAnchor, TMember>;
 type RecursiveCteSelf<TName extends string, TAnchor extends SelectQuery<any>> = CteSource<TName, QueryRow<TAnchor>, CteMetadata<TAnchor>, QuerySqlTypeMap<TAnchor>>;
 /** The typed source returned by {@link recursiveCte}. */
@@ -3214,33 +3284,32 @@ type AnyCteSource = Source<any> & {
 };
 declare function cte<const TName extends string, TQuery extends AnyQuery>(name: TName, query: TQuery): CteSource<TName, QueryRow<TQuery>, RequiresOuterMetadataOf<TQuery> | CapabilityMetadataOf<TQuery>, QuerySqlTypeMap<TQuery>>;
 /**
- * Define a typed recursive `WITH` source from an anchor and one recursive
- * member. The callback receives a forward reference that must be introduced
- * through the member query's normal FROM or JOIN scope.
+ * Define a typed recursive `WITH` source from an anchor and one recursive member. The callback
+ * receives a forward reference that must be introduced through the member query's normal FROM or
+ * JOIN scope.
  */
 declare function recursiveCte<const TName extends string, TAnchor extends SelectQuery<any>, TMember extends SelectQuery<any>>(name: TName, anchor: TAnchor, member: ((self: RecursiveCteSelf<TName, TAnchor>) => TMember) & ((self: RecursiveCteSelf<TName, TAnchor>) => TMember & RecursiveMemberValidation<NoInfer<TAnchor>, NoInfer<TMember>>)): RecursiveCteSource<TName, TAnchor, TMember>;
 interface WithClause<TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'with';
+  readonly clauseKind: "with";
   readonly ctes: readonly AnyCteSource[];
 }
 declare function withCte<const TCtes extends readonly AnyCteSource[]>(...ctes: TCtes): WithClause<RequiresOuterMetadataOf<TCtes[number]> | CapabilityMetadataOf<TCtes[number]>>;
 //#endregion
 //#region src/query/select/types.d.ts
-interface SelectQuery<TConfig extends QueryConfig = {}> extends Query$1<TConfig> {
-  readonly queryKind: 'select';
+interface SelectQuery<TConfig extends QueryConfig = {}> extends Query<TConfig> {
+  readonly queryKind: "select";
 }
 type ExactlyOneSafeClause = DistinctClause | OrderByClause<any> | RowLockClause | WithClause;
 type AtMostOneClause = FetchClause<0 | 1>;
 type UnconditionalAtMostOneClause<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? never : Extract<TParts[TIndex], AtMostOneClause>; }[number];
 type ConditionalPaginationClause<TParts extends readonly SelectPart[]> = { [TIndex in keyof TParts]: Omit$1 extends TParts[TIndex] ? Extract<TParts[TIndex], AnyPaginationClause> : never; }[number];
 /**
- * SELECT cardinality is intentionally conservative. A literal FETCH/LIMIT
- * bound of zero or one proves an upper bound only when it is unconditional;
- * an otherwise source-free query has one row unless a known row-reducing
- * clause is present. Conditional pagination, predicates, and arbitrary clauses
- * do not prove exactness.
+ * SELECT cardinality is intentionally conservative. A literal FETCH/LIMIT bound of zero or one
+ * proves an upper bound only when it is unconditional; an otherwise source-free query has one row
+ * unless a known row-reducing clause is present. Conditional pagination, predicates, and arbitrary
+ * clauses do not prove exactness.
  */
-type SelectCardinality<TParts extends readonly SelectPart[]> = UnconditionalAtMostOneClause<TParts> extends never ? ConditionalPaginationClause<TParts> extends never ? Exclude<TParts[number], ExactlyOneSafeClause | Omit$1> extends never ? 'exactly-one' : 'many' : 'many' : 'zero-or-one';
+type SelectCardinality<TParts extends readonly SelectPart[]> = UnconditionalAtMostOneClause<TParts> extends never ? ConditionalPaginationClause<TParts> extends never ? Exclude<TParts[number], ExactlyOneSafeClause | Omit$1> extends never ? "exactly-one" : "many" : "many" : "zero-or-one";
 type ClauseScope<TClause> = TClause extends FromClause ? FromScope<TClause> : TClause extends JoinClause<infer TSource, any> ? ProvidedSourceIdentity<TSource> : never;
 type AvailableScope<TClauses extends readonly AnySelectClause[]> = ClauseScope<TClauses[number]>;
 type AvailableOuterScope<TClauses extends readonly AnySelectClause[]> = ProvidesOuterOf<TClauses[number]>;
@@ -3248,7 +3317,7 @@ type NullableSources<TClauses extends readonly AnySelectClause[]> = NullableSour
 type RequiredScope<TSelection, TClauses extends readonly AnySelectClause[]> = SelectionRequires<TSelection> | RequiresOuterOf<SelectionItems<TSelection>> | RequiresOf<TClauses[number]> | RequiresOuterOf<TClauses[number]>;
 type MissingScope<TSelection, TClauses extends readonly AnySelectClause[]> = Exclude<RequiredScope<TSelection, TClauses>, AvailableScope<TClauses> | AvailableOuterScope<TClauses>>;
 type RequiredOuterScope<TSelection, TClauses extends readonly AnySelectClause[]> = Extract<Exclude<RequiredScope<TSelection, TClauses>, AvailableScope<TClauses>>, AvailableOuterScope<TClauses>>;
-type ScopeValidation<TSelection, TClauses extends readonly AnySelectClause[]> = [MissingScope<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'select.scope', 'Add a FROM, JOIN, or correlate() clause that provides the referenced source.', MissingScope<TSelection, TClauses>>;
+type ScopeValidation<TSelection, TClauses extends readonly AnySelectClause[]> = [MissingScope<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "select.scope", "Add a FROM, JOIN, or correlate() clause that provides the referenced source.", MissingScope<TSelection, TClauses>>;
 type GroupingRuleClause = HavingClause<any> | OrderByClause<any>;
 type HasGroupByClause<TClauses extends readonly AnySelectClause[]> = Extract<TClauses[number], GroupByClause<any>> extends never ? false : true;
 type HasHavingClause<TClauses extends readonly AnySelectClause[]> = Extract<TClauses[number], HavingClause<any>> extends never ? false : true;
@@ -3256,14 +3325,14 @@ type GroupingRuleClauses<TClauses extends readonly AnySelectClause[]> = Extract<
 type RequiresGrouping<TSelection, TClauses extends readonly AnySelectClause[]> = HasGroupByClause<TClauses> extends true ? true : HasHavingClause<TClauses> extends true ? true : HasAggregate<SelectionItems<TSelection> | GroupingRuleClauses<TClauses>>;
 type ClauseSource<TClause> = TClause extends FromClause ? FromSource<TClause> : TClause extends JoinClause<infer TSource, any> ? TSource : never;
 type ConstraintDeterminesSource<TConstraint, TSource extends AnySource, TGroupedDependencies> = TConstraint extends {
-  readonly kind: 'primary-key' | 'unique';
+  readonly kind: "primary-key" | "unique";
   readonly columns: infer TColumns;
 } ? TColumns extends readonly ColumnReference<string, any>[] ? [DependenciesOf<TColumns[number]>] extends [ColumnDependency<any, any>] ? [ColumnDependency<SourceIdentity<TSource>, DependenciesOf<TColumns[number]> extends ColumnDependency<any, infer TName extends string> ? TName : never>] extends [TGroupedDependencies] ? true : false : false : false : false;
-type IndexTermExpression$2<T> = T extends OrderTerm<any> ? T['expression'] : T;
+type IndexTermExpression$1<T> = T extends OrderTerm<any> ? T["expression"] : T;
 type IndexDeterminesSource<TIndex, TSource extends AnySource, TGroupedDependencies> = TIndex extends {
   readonly candidateKey: true;
   readonly terms: infer TTerms extends readonly unknown[];
-} ? [DependenciesOf<IndexTermExpression$2<TTerms[number]>>] extends [ColumnDependency<any, any>] ? [ColumnDependency<SourceIdentity<TSource>, DependenciesOf<IndexTermExpression$2<TTerms[number]>> extends ColumnDependency<any, infer TName extends string> ? TName : never>] extends [TGroupedDependencies] ? true : false : false : false;
+} ? [DependenciesOf<IndexTermExpression$1<TTerms[number]>>] extends [ColumnDependency<any, any>] ? [ColumnDependency<SourceIdentity<TSource>, DependenciesOf<IndexTermExpression$1<TTerms[number]>> extends ColumnDependency<any, infer TName extends string> ? TName : never>] extends [TGroupedDependencies] ? true : false : false : false;
 type SourceIndexes<T> = T extends {
   readonly indexes: infer TIndexes extends SourceIndexesRecord;
 } ? TIndexes : {};
@@ -3275,12 +3344,11 @@ type ClauseGroupingFailures<TClauses extends readonly AnySelectClause[]> = TClau
 type GroupByAggregateFailures<TClauses extends readonly AnySelectClause[]> = TClauses[number] extends (infer TClause) ? TClause extends GroupByClause<any> ? HasAggregate<TClause> extends true ? TClause : never : never : never;
 type GroupingFailures<TSelection, TClauses extends readonly AnySelectClause[]> = SelectionGroupingFailures<TSelection, TClauses> | ClauseGroupingFailures<TClauses> | GroupByAggregateFailures<TClauses>;
 /**
- * Enforce the grouped-query rule: visible column dependencies must be grouped
- * or functionally determined by a grouped, declared key from the same source.
- * Aggregate arguments are consumed by the aggregate. Non-column GROUP BY
- * expressions are accepted as exact grouping keys only.
+ * Enforce the grouped-query rule: visible column dependencies must be grouped or functionally
+ * determined by a grouped, declared key from the same source. Aggregate arguments are consumed by
+ * the aggregate. Non-column GROUP BY expressions are accepted as exact grouping keys only.
  */
-type GroupingValidation<TSelection, TClauses extends readonly AnySelectClause[]> = RequiresGrouping<TSelection, TClauses> extends true ? [GroupingFailures<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<'invalid-grouping', 'select.grouping', 'Group every visible dependency or project it through an aggregate.', GroupingFailures<TSelection, TClauses>> : unknown;
+type GroupingValidation<TSelection, TClauses extends readonly AnySelectClause[]> = RequiresGrouping<TSelection, TClauses> extends true ? [GroupingFailures<TSelection, TClauses>] extends [never] ? unknown : QueryTypeValidation<"invalid-grouping", "select.grouping", "Group every visible dependency or project it through an aggregate.", GroupingFailures<TSelection, TClauses>> : unknown;
 //#endregion
 //#region src/query/select.d.ts
 type SelectMetadata<TSelection, TClauses extends readonly AnySelectClause[]> = ([RequiredOuterScope<TSelection, TClauses>] extends [never] ? never : RequiresOuterSourceMeta<RequiredOuterScope<TSelection, TClauses>>) | CapabilityMetadataOf<SelectionItems<TSelection> | TClauses[number]>;
@@ -3293,19 +3361,18 @@ declare function select<const TSelection extends Selection, const TParts extends
 //#endregion
 //#region src/query/clauses/correlate.d.ts
 /**
- * Provision an enclosing source to a correlated SELECT. The clause emits no
- * SQL; select() consumes the provision and records any actually used source
- * as a requirement on the resulting query.
+ * Provision an enclosing source to a correlated SELECT. The clause emits no SQL; select() consumes
+ * the provision and records any actually used source as a requirement on the resulting query.
  */
 interface CorrelateClause<TSources extends readonly AnySource[] = readonly AnySource[]> extends SelectClause<ProvidesOuterSourceMeta<SourceIdentity<TSources[number]>>> {
-  readonly clauseKind: 'correlate';
+  readonly clauseKind: "correlate";
   readonly sources: TSources;
 }
 declare function correlate<const TSources extends readonly [AnySource, ...AnySource[]]>(...sources: TSources): CorrelateClause<TSources>;
 //#endregion
 //#region src/query/mutation/returning.d.ts
 interface ReturningClause<TSelection extends Selection = Selection> extends Fragment<SelectionMetadata<TSelection>> {
-  readonly clauseKind: 'returning';
+  readonly clauseKind: "returning";
   readonly selection: TSelection;
   readonly row: SelectionOutput<TSelection>;
   readonly resultShape: ResultShape;
@@ -3316,52 +3383,52 @@ type ReturningSqlTypes<T> = [T] extends [ReturningClause<infer TSelection>] ? Se
 declare function returning<const TSelection extends Selection>(selection: TSelection): ReturningClause<TSelection>;
 //#endregion
 //#region src/query/mutation/types.d.ts
-type MutationKind = 'insert' | 'update' | 'delete';
-interface MutationQueryConfig extends Omit<QueryConfig, 'cardinality'> {
+type MutationKind = "insert" | "update" | "delete";
+interface MutationQueryConfig extends Omit<QueryConfig, "cardinality"> {
   readonly kind?: MutationKind;
 }
 type MutationConfigValue<TConfig, TKey extends PropertyKey, TFallback> = TKey extends keyof TConfig ? TConfig[TKey] : TFallback;
-type MutationConfigRow<TConfig> = Extract<MutationConfigValue<TConfig, 'row', Record<string, unknown>>, object>;
-type MutationConfigKind<TConfig> = Extract<MutationConfigValue<TConfig, 'kind', MutationKind>, MutationKind>;
-interface MutationQuery<TConfig extends MutationQueryConfig = {}> extends Query$1<{
+type MutationConfigRow<TConfig> = Extract<MutationConfigValue<TConfig, "row", Record<string, unknown>>, object>;
+type MutationConfigKind<TConfig> = Extract<MutationConfigValue<TConfig, "kind", MutationKind>, MutationKind>;
+interface MutationQuery<TConfig extends MutationQueryConfig = {}> extends Query<{
   readonly row: MutationConfigRow<TConfig>;
-  readonly cardinality: 'many';
-  readonly metadata: MutationConfigValue<TConfig, 'metadata', never>;
-  readonly sqlTypes: MutationConfigValue<TConfig, 'sqlTypes', UnknownSourceSqlTypes<MutationConfigRow<TConfig>>>;
+  readonly cardinality: "many";
+  readonly metadata: MutationConfigValue<TConfig, "metadata", never>;
+  readonly sqlTypes: MutationConfigValue<TConfig, "sqlTypes", UnknownSourceSqlTypes<MutationConfigRow<TConfig>>>;
 }> {
   readonly queryKind: MutationConfigKind<TConfig>;
 }
 type MutationCapabilityMetadata<T> = CapabilityMetadataOf<T>;
 interface AllowAllClause extends Fragment<never> {
-  readonly clauseKind: 'allow-all';
+  readonly clauseKind: "allow-all";
 }
 declare function allowAll(): AllowAllClause;
 type MutationConditionClause = WhereClause<any>;
 type MutationClause = MutationConditionClause | AllowAllClause | MutationReturningClause;
-type MutationSafetyValidation<TClauses extends readonly unknown[]> = Extract<TClauses[number], MutationConditionClause | AllowAllClause> extends never ? QueryTypeValidation<'unsafe-mutation', 'mutation.safety', 'Add where(...) or allowAll() explicitly.'> : unknown;
+type MutationSafetyValidation<TClauses extends readonly unknown[]> = Extract<TClauses[number], MutationConditionClause | AllowAllClause> extends never ? QueryTypeValidation<"unsafe-mutation", "mutation.safety", "Add where(...) or allowAll() explicitly."> : unknown;
 type MutationReturningClause = ReturningClause<any>;
 type MutationReturning<TClauses extends readonly unknown[]> = Extract<TClauses[number], MutationReturningClause>;
 type MutationRow<TClauses extends readonly unknown[]> = ReturningRow<MutationReturning<TClauses>>;
 type MutationSqlTypes<TClauses extends readonly unknown[]> = ReturningSqlTypes<MutationReturning<TClauses>>;
-type MutationScopeValidation<TSource, TClauses extends readonly unknown[]> = [Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'mutation.scope', 'Use clauses that reference the mutation table or an explicitly correlated source.', Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>>;
+type MutationScopeValidation<TSource, TClauses extends readonly unknown[]> = [Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "mutation.scope", "Use clauses that reference the mutation table or an explicitly correlated source.", Exclude<RequiresOf<TClauses[number]>, SourceIdentity<TSource>>>;
 //#endregion
 //#region src/query/mutation/update.d.ts
 /** A value, target-compatible expression, or explicitly omitted update field. */
 type UpdateAssignmentValue<T> = T | ExpressionWithOutput<T> | Omit$1;
 /** Writable table fields accepted by {@link update}. */
-type UpdateAssignments<TTable extends AnyTable> = { -readonly [K in keyof TableUpdateInput<TTable['definitions']>]?: UpdateAssignmentValue<TableUpdateInput<TTable['definitions']>[K]>; };
-type InvalidUpdateAssignments<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? unknown : QueryTypeValidation<'invalid-update', 'update.assignments', 'Use only columns declared by the update table.', Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<'invalid-update', 'update.assignments', 'Provide values or expressions matching the update table columns.', TAssignments>;
-type AssignmentScopeValidation<TTable extends AnyTable, TAssignments> = [Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'update.assignments', 'Use expressions scoped to the update table.', Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>>;
+type UpdateAssignments<TTable extends AnyTable> = { -readonly [K in keyof TableUpdateInput<TTable["definitions"]>]?: UpdateAssignmentValue<TableUpdateInput<TTable["definitions"]>[K]>; };
+type InvalidUpdateAssignments<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? unknown : QueryTypeValidation<"invalid-update", "update.assignments", "Use only columns declared by the update table.", Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<"invalid-update", "update.assignments", "Provide values or expressions matching the update table columns.", TAssignments>;
+type AssignmentScopeValidation<TTable extends AnyTable, TAssignments> = [Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "update.assignments", "Use expressions scoped to the update table.", Exclude<RequiresOf<TAssignments extends object ? TAssignments[keyof TAssignments] : never>, SourceIdentity<TTable>>>;
 declare function update<const TTable extends AnyTable, const TAssignments extends object, const TClauses extends readonly MutationClause[]>(table: TTable, assignments: TAssignments & InvalidUpdateAssignments<TTable, TAssignments> & AssignmentScopeValidation<TTable, TAssignments>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
-  readonly kind: 'update';
+  readonly kind: "update";
   readonly metadata: MutationCapabilityMetadata<TClauses[number] | (TAssignments extends object ? TAssignments[keyof TAssignments] : never)>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
 //#region src/query/mutation/on-conflict.d.ts
 type ExcludedIdentity<TTableIdentity> = {
-  readonly sourceKind: 'excluded';
+  readonly sourceKind: "excluded";
   readonly table: TTableIdentity;
 };
 type ExcludedSource<TTable extends AnyTable> = Source<{
@@ -3373,10 +3440,10 @@ type ExcludedSqlTypes<TTable extends AnyTable> = SourceSqlTypeMap<TTable> & Sour
 /** Columns from the proposed INSERT row, available inside DO UPDATE. */
 declare function excluded<const TTable extends AnyTable>(table: TTable): ExcludedSource<TTable>;
 interface DoNothingAction {
-  readonly actionKind: 'do-nothing';
+  readonly actionKind: "do-nothing";
 }
 interface DoUpdateAction<TAssignments extends object = object, TWhere extends WhereClause<any> | undefined = WhereClause<any> | undefined> {
-  readonly actionKind: 'do-update';
+  readonly actionKind: "do-update";
   readonly assignments: TAssignments;
   readonly where: TWhere;
 }
@@ -3391,12 +3458,12 @@ type TableKeyConstraint<TTable extends AnyTable> = Extract<TableConstraints<TTab
 /** A declared primary or non-null unique key used as an upsert target. */
 type ConflictTarget<TTable extends AnyTable = AnyTable> = TableKeyConstraint<TTable>;
 type ConflictSources<TTable extends AnyTable> = SourceIdentity<TTable> | ExcludedIdentity<SourceIdentity<TTable>>;
-type ConflictAssignmentValidation<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? [Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'upsert.update.assignments', 'Use expressions scoped to the target table or excluded row.', Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>> : QueryTypeValidation<'invalid-update', 'upsert.update.assignments', 'Use only writable columns declared by the target table.', Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<'invalid-update', 'upsert.update.assignments', 'Provide values or expressions matching the target table update columns.', TAssignments>;
-type ConflictWhereValidation<TTable extends AnyTable, TWhere> = TWhere extends undefined ? unknown : [Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<'missing-source', 'upsert.update.where', 'Use expressions scoped to the target table or excluded row.', Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>>;
+type ConflictAssignmentValidation<TTable extends AnyTable, TAssignments> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? [Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "upsert.update.assignments", "Use expressions scoped to the target table or excluded row.", Exclude<RequiresOf<TAssignments[keyof TAssignments]>, ConflictSources<TTable>>> : QueryTypeValidation<"invalid-update", "upsert.update.assignments", "Use only writable columns declared by the target table.", Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>>> : QueryTypeValidation<"invalid-update", "upsert.update.assignments", "Provide values or expressions matching the target table update columns.", TAssignments>;
+type ConflictWhereValidation<TTable extends AnyTable, TWhere> = TWhere extends undefined ? unknown : [Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>] extends [never] ? unknown : QueryTypeValidation<"missing-source", "upsert.update.where", "Use expressions scoped to the target table or excluded row.", Exclude<RequiresOf<TWhere>, ConflictSources<TTable>>>;
 type ConflictActionValidation<TTable extends AnyTable, TAction extends ConflictAction> = TAction extends DoUpdateAction<infer TAssignments, infer TWhere> ? ConflictAssignmentValidation<TTable, TAssignments> & ConflictWhereValidation<TTable, TWhere> : unknown;
 type ConflictActionCapabilities<TAction extends ConflictAction> = TAction extends DoUpdateAction<infer TAssignments, infer TWhere> ? CapabilityMetadataOf<TAssignments[keyof TAssignments] | Exclude<TWhere, undefined>> : never;
-interface OnConflictClause<TAction extends ConflictAction = ConflictAction> extends Fragment<RequiresCapabilityMeta<'on-conflict'> | ConflictActionCapabilities<TAction>> {
-  readonly clauseKind: 'on-conflict';
+interface OnConflictClause<TAction extends ConflictAction = ConflictAction> extends Fragment<RequiresCapabilityMeta<"on-conflict"> | ConflictActionCapabilities<TAction>> {
+  readonly clauseKind: "on-conflict";
   readonly target: KeyConstraint | undefined;
   readonly action: TAction;
 }
@@ -3406,32 +3473,32 @@ declare function onConflict<const TTable extends AnyTable, const TTarget extends
 //#endregion
 //#region src/query/mutation/insert.d.ts
 interface ValuesSource<TRows extends readonly object[] = readonly object[]> {
-  readonly insertKind: 'values';
+  readonly insertKind: "values";
   readonly rows: TRows;
 }
 declare function values<const TRows extends readonly [object, ...object[]]>(...rows: TRows): ValuesSource<TRows>;
 interface DefaultValuesSource {
-  readonly insertKind: 'default-values';
+  readonly insertKind: "default-values";
 }
 declare function defaultValues(): DefaultValuesSource;
 interface InsertSelectSource<TQuery extends AnyQuery = AnyQuery, TColumns extends readonly string[] = readonly string[]> {
-  readonly insertKind: 'select';
+  readonly insertKind: "select";
   readonly query: TQuery;
   readonly columns: TColumns;
 }
 declare function insertSelect<TQuery extends AnyQuery, const TColumns extends readonly [string, ...string[]]>(query: TQuery, columns: TColumns): InsertSelectSource<TQuery, TColumns>;
 type InsertSource = ValuesSource<any> | DefaultValuesSource | InsertSelectSource<any, any>;
 type InsertSourceCapabilityMetadata<TSource extends InsertSource> = TSource extends InsertSelectSource<infer TQuery, any> ? CapabilityMetadataOf<TQuery> : never;
-type InsertRow<TTable extends AnyTable> = TableInsertInput<TTable['definitions']>;
-type InvalidInsertRow<TTable extends AnyTable, TRow> = TRow extends InsertRow<TTable> ? Exclude<keyof TRow, keyof InsertRow<TTable>> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.values.columns', 'Use only columns declared by the insert table.', Exclude<keyof TRow, keyof InsertRow<TTable>>> : QueryTypeValidation<'invalid-insert', 'insert.values.row', 'Provide values matching the insert table columns.', TRow>;
-type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> = TSource extends ValuesSource<infer TRows> ? TRows[number] extends (infer TRow) ? InvalidInsertRow<TTable, TRow> : never : TSource extends DefaultValuesSource ? Exclude<keyof TTable['definitions'], { [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? K : TTable['definitions'][K] extends {
+type InsertRow<TTable extends AnyTable> = TableInsertInput<TTable["definitions"]>;
+type InvalidInsertRow<TTable extends AnyTable, TRow> = TRow extends InsertRow<TTable> ? Exclude<keyof TRow, keyof InsertRow<TTable>> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.values.columns", "Use only columns declared by the insert table.", Exclude<keyof TRow, keyof InsertRow<TTable>>> : QueryTypeValidation<"invalid-insert", "insert.values.row", "Provide values matching the insert table columns.", TRow>;
+type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> = TSource extends ValuesSource<infer TRows> ? TRows[number] extends (infer TRow) ? InvalidInsertRow<TTable, TRow> : never : TSource extends DefaultValuesSource ? Exclude<keyof TTable["definitions"], { [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? K : TTable["definitions"][K] extends {
   hasDefault: true;
-} ? K : never; }[keyof TTable['definitions']]> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.default-values', 'Provide values for required columns or define defaults for them.', Exclude<keyof TTable['definitions'], { [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? K : TTable['definitions'][K] extends {
+} ? K : never; }[keyof TTable["definitions"]]> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.default-values", "Provide values for required columns or define defaults for them.", Exclude<keyof TTable["definitions"], { [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? K : TTable["definitions"][K] extends {
   hasDefault: true;
-} ? K : never; }[keyof TTable['definitions']]>> : TSource extends InsertSelectSource<any, infer TColumns> ? Exclude<TColumns[number], keyof TTable['definitions']> extends never ? Exclude<{ [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? never : ColumnHasDefault<TTable['definitions'][K]> extends true ? never : K; }[keyof TTable['definitions']], TColumns[number]> extends never ? unknown : QueryTypeValidation<'invalid-insert', 'insert.select.columns', 'Include every required insert column in the target list.', Exclude<{ [K in keyof TTable['definitions']]-?: ColumnIsGenerated<TTable['definitions'][K]> extends true ? never : ColumnHasDefault<TTable['definitions'][K]> extends true ? never : K; }[keyof TTable['definitions']], TColumns[number]>> : QueryTypeValidation<'invalid-insert', 'insert.select.columns', 'Use only columns declared by the insert table.', Exclude<TColumns[number], keyof TTable['definitions']>> : never;
+} ? K : never; }[keyof TTable["definitions"]]>> : TSource extends InsertSelectSource<any, infer TColumns> ? Exclude<TColumns[number], keyof TTable["definitions"]> extends never ? Exclude<{ [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? never : ColumnHasDefault<TTable["definitions"][K]> extends true ? never : K; }[keyof TTable["definitions"]], TColumns[number]> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.select.columns", "Include every required insert column in the target list.", Exclude<{ [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? never : ColumnHasDefault<TTable["definitions"][K]> extends true ? never : K; }[keyof TTable["definitions"]], TColumns[number]>> : QueryTypeValidation<"invalid-insert", "insert.select.columns", "Use only columns declared by the insert table.", Exclude<TColumns[number], keyof TTable["definitions"]>> : never;
 declare function insertInto<const TTable extends AnyTable, const TSource extends InsertSource, const TClauses extends readonly InsertClause[]>(table: TTable, source: TSource & ValidInsertSource<TTable, TSource>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
-  readonly kind: 'insert';
+  readonly kind: "insert";
   readonly metadata: MutationCapabilityMetadata<TClauses[number]> | InsertSourceCapabilityMetadata<TSource>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
@@ -3439,16 +3506,16 @@ declare function insertInto<const TTable extends AnyTable, const TSource extends
 //#region src/query/mutation/delete.d.ts
 declare function deleteFrom<const TTable extends AnyTable, const TClauses extends readonly MutationClause[]>(table: TTable, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & MutationSafetyValidation<TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
-  readonly kind: 'delete';
+  readonly kind: "delete";
   readonly metadata: MutationCapabilityMetadata<TClauses[number]>;
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
 //#region src/query/clauses/order-by.d.ts
-type OrderDirection = 'ASC' | 'DESC';
-type NullsOrder = 'FIRST' | 'LAST';
+type OrderDirection = "ASC" | "DESC";
+type NullsOrder = "FIRST" | "LAST";
 interface OrderTerm<TMetadata = never, TExpression extends AnyExpression = AnyExpression> extends Fragment<TMetadata> {
-  readonly orderKind: 'term';
+  readonly orderKind: "term";
   readonly expression: TExpression;
   readonly direction?: OrderDirection;
   readonly nulls?: NullsOrder;
@@ -3469,7 +3536,7 @@ declare function nullsLast<TExpression extends AnyExpression>(expression: TExpre
   readonly kind: "result" | "cardinality";
 } ? never : T : never : never, TExpression & SqlCapabilityValidation<ExpressionSqlType<TExpression>, SqlOrderable<unknown>>>;
 interface OrderByClause<TMetadata = never> extends SelectClause<TMetadata> {
-  readonly clauseKind: 'order-by';
+  readonly clauseKind: "order-by";
   readonly terms: readonly OrderTerm<any>[];
 }
 type OrderByPart = AnyExpression | OrderTerm<any> | Omit$1;
@@ -3478,86 +3545,6 @@ type OrderByComposition<TParts extends readonly OrderByPart[]> = [PresentOrderPa
 type OrderPartsValidation<TParts extends readonly unknown[]> = TParts extends readonly [infer THead, ...infer TTail] ? (THead extends Omit$1 ? unknown : THead extends AnyExpression ? SqlCapabilityValidation<ExpressionSqlType<THead>, SqlOrderable> : unknown) & OrderPartsValidation<TTail> : unknown;
 declare function orderBy<const TParts extends readonly OrderByPart[]>(...parts: TParts & OrderPartsValidation<TParts>): OrderByComposition<TParts>;
 //#endregion
-//#region src/schema/indexes.d.ts
-type IndexTerm = AnyExpression | OrderTerm<any>;
-/** PostgreSQL-specific index method and storage metadata. */
-interface PostgresIndexExtension extends SchemaDialectExtension<'postgresql'> {
-  readonly method?: 'btree' | 'hash' | 'gist' | 'spgist' | 'gin' | 'brin';
-  readonly concurrently?: boolean;
-  readonly operatorClasses?: Readonly<Record<string, string>>;
-  readonly storageParameters?: Readonly<Record<string, string | number | boolean>>;
-}
-/** SQLite-specific index metadata retained for a future adapter. */
-interface SqliteIndexExtension extends SchemaDialectExtension<'sqlite'> {
-  readonly auto?: boolean;
-}
-/** MySQL-specific index algorithm, locking, and parser metadata. */
-interface MysqlIndexExtension extends SchemaDialectExtension<'mysql'> {
-  readonly algorithm?: 'default' | 'inplace' | 'copy';
-  readonly lock?: 'default' | 'none' | 'shared' | 'exclusive';
-  readonly using?: 'btree' | 'hash' | 'rtree';
-  readonly parser?: string;
-  readonly keyBlockSize?: number;
-}
-/** First-party and user-defined dialect extensions for indexes. */
-type IndexDialectExtension = PostgresIndexExtension | SqliteIndexExtension | MysqlIndexExtension | (SchemaDialectExtension<string> & Readonly<Record<string, unknown>>);
-interface IndexOptions<TPredicate extends AnyExpression | undefined = AnyExpression | undefined, TExtension extends IndexDialectExtension | undefined = IndexDialectExtension | undefined> extends SchemaObjectNameOptions {
-  readonly unique?: boolean;
-  readonly where?: TPredicate;
-  /** Columns stored in the index payload but not used as key terms. */
-  readonly include?: readonly ColumnReference<string, any>[];
-  /** Typed engine-specific index options. */
-  readonly dialect?: TExtension;
-}
-type IndexTermExpression$1<TTerm> = TTerm extends OrderTerm<any> ? TTerm['expression'] : TTerm;
-type IsNullableIndexColumn<TColumn> = [DeclaredColumnNullabilityOf<TColumn>] extends [never] ? null extends OutputOf<TColumn> ? true : false : true extends DeclaredColumnNullabilityOf<TColumn> ? true : false;
-type IsEligibleColumn<TTerm> = IndexTermExpression$1<TTerm> extends (infer TExpression) ? TExpression extends ColumnReference<string, any> ? IsNullableIndexColumn<TExpression> extends true ? false : true : false : false;
-type AllEligibleColumns<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: IsEligibleColumn<TTerms[K]>; }[number] extends (infer TEligibility) ? false extends TEligibility ? true extends TEligibility ? boolean : false : true : false;
-type BooleanOption<TValue> = [Extract<TValue, true>] extends [never] ? false : [Exclude<TValue, true>] extends [never] ? true : boolean;
-type UniqueOption<TOptions> = 'unique' extends keyof TOptions ? BooleanOption<TOptions['unique']> : false;
-type PredicateOption<TOptions> = 'where' extends keyof TOptions ? TOptions['where'] : undefined;
-type DialectOption<TOptions> = TOptions extends {
-  readonly dialect?: infer TDialect;
-} ? unknown extends TDialect ? IndexDialectExtension | undefined : TDialect : undefined;
-type PredicatePresence<TOptions> = [Exclude<PredicateOption<TOptions>, undefined>] extends [never] ? false : undefined extends PredicateOption<TOptions> ? boolean : true;
-type IsCandidateKey<TTerms extends readonly IndexTerm[], TOptions extends IndexOptions<any>> = UniqueOption<TOptions> extends (infer TUnique) ? PredicatePresence<TOptions> extends (infer THasPredicate) ? AllEligibleColumns<TTerms> extends (infer TEligible) ? TUnique extends false ? false : THasPredicate extends true ? false : TEligible extends false ? false : TUnique extends true ? THasPredicate extends false ? TEligible extends true ? true : boolean : boolean : boolean : false : false : false;
-/** Portable index metadata retained by a table and its aliases. */
-interface TableIndex<TTerms extends readonly IndexTerm[] = any, TOptions extends IndexOptions<any> = any> extends SchemaObjectIdentity {
-  readonly kind: 'index';
-  readonly terms: TTerms;
-  readonly unique: UniqueOption<TOptions>;
-  readonly predicate: PredicateOption<TOptions>;
-  readonly includedColumns?: TOptions extends {
-    readonly include: infer TIncluded;
-  } ? TIncluded : undefined;
-  readonly dialect?: DialectOption<TOptions>;
-  readonly candidateKey: IsCandidateKey<TTerms, TOptions>;
-}
-/** The widened index shape accepted by source metadata records. */
-interface SourceIndex {
-  readonly kind: 'index';
-  readonly terms: readonly IndexTerm[];
-  readonly unique: boolean;
-  readonly predicate: AnyExpression | undefined;
-  readonly includedColumns?: readonly ColumnReference<string, any>[];
-  readonly dialect?: IndexDialectExtension;
-  readonly candidateKey: boolean;
-}
-type SourceIndexesRecord = Readonly<Record<string, SourceIndex>>;
-/**
- * Validate portable and dialect-owned index facts for one target adapter.
- * Unsupported features are reported as data so a serializer can aggregate
- * diagnostics instead of failing during traversal with an opaque exception.
- */
-declare function validateIndexDialect(indexMetadata: SourceIndex, dialect: string, path?: readonly (string | number)[]): readonly SchemaMetadataDiagnostic[];
-type ValidIndexExpression<T> = T extends AnyExpression ? HasAggregate<T> extends true ? never : HasWindow<T> extends true ? never : HasSubquery<T> extends true ? never : unknown : never;
-type InvalidIndexTerms<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: TTerms[K] extends OrderTerm<any> ? TTerms[K] extends {
-  readonly nulls: 'FIRST' | 'LAST';
-} ? TTerms[K] : ValidIndexExpression<TTerms[K]['expression']> extends never ? TTerms[K] : never : ValidIndexExpression<TTerms[K]> extends never ? TTerms[K] : never; }[number];
-type IndexTermsValidation<TTerms extends readonly IndexTerm[]> = [InvalidIndexTerms<TTerms>] extends [never] ? unknown : never;
-/** Declare a portable column or expression index. */
-declare function index<const TTerms extends readonly [IndexTerm, ...IndexTerm[]], const TOptions extends IndexOptions<any> = {}>(terms: TTerms & IndexTermsValidation<NoInfer<TTerms>>, options?: TOptions): TableIndex<TTerms, TOptions>;
-//#endregion
 //#region src/schema/table.d.ts
 type TableDefinitions = Record<string, ColumnDefinition<any>>;
 type AnyTable = Source<any> & {
@@ -3574,7 +3561,7 @@ type OptionalInsertKeys<TDefinitions extends TableDefinitions> = Exclude<keyof T
 type TableInsertInput<TDefinitions extends TableDefinitions> = { -readonly [K in RequiredInsertKeys<TDefinitions>]: ColumnInsertInput<TDefinitions[K]>; } & { -readonly [K in OptionalInsertKeys<TDefinitions>]?: ColumnInsertInput<TDefinitions[K]>; };
 type TableUpdateInput<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions as ColumnIsGenerated<TDefinitions[K]> extends true ? never : K]?: ColumnUpdateInput<TDefinitions[K]>; };
 type TableIdentity<TName extends string> = {
-  readonly sourceKind: 'table';
+  readonly sourceKind: "table";
   readonly tableName: TName;
 };
 type TableColumns<TDefinitions extends TableDefinitions, TIdentity> = { readonly [K in keyof TDefinitions]: SourceColumns<TableRow<TDefinitions>, TIdentity, TableSqlTypes<TDefinitions>>[K] & DeclaredColumnNullability<ColumnIsNullable<TDefinitions[K]>>; };
@@ -3602,7 +3589,7 @@ type InvalidConstraintDependencies<TName extends string, TConstraints extends So
 type InvalidExpression<TExpression, TName extends string> = TExpression extends AnyExpression ? Exclude<DependenciesOf<TExpression>, ColumnDependency<TableIdentity<TName>, string>> extends never ? HasAggregate<TExpression> extends true ? TExpression : HasWindow<TExpression> extends true ? TExpression : HasSubquery<TExpression> extends true ? TExpression : never : TExpression : TExpression;
 type ResolvedTarget<T> = T extends (() => infer TResolved) ? TResolved : T;
 type SameColumnTuple<TLeft extends readonly unknown[], TRight extends readonly unknown[]> = TLeft extends readonly [infer TLeftHead, ...infer TLeftTail] ? TRight extends readonly [infer TRightHead, ...infer TRightTail] ? [DependenciesOf<TLeftHead>] extends [DependenciesOf<TRightHead>] ? [DependenciesOf<TRightHead>] extends [DependenciesOf<TLeftHead>] ? SameColumnTuple<TLeftTail, TRightTail> : false : false : false : TRight extends readonly [] ? true : false;
-type IndexTermExpression<T> = T extends OrderTerm<any> ? T['expression'] : T;
+type IndexTermExpression<T> = T extends OrderTerm<any> ? T["expression"] : T;
 type IndexColumns<TTerms extends readonly IndexTerm[]> = { [K in keyof TTerms]: IndexTermExpression<TTerms[K]>; };
 type IndexIncludedColumns<TIndex> = TIndex extends {
   readonly includedColumns?: infer TIncluded;
@@ -3615,15 +3602,15 @@ type IndexesOf<T> = T extends {
   readonly indexes: infer TIndexes extends SourceIndexesRecord;
 } ? TIndexes : {};
 type HasMatchingConstraint<TColumns, TConstraints> = TConstraints extends SourceConstraintsRecord ? true extends { [K in keyof TConstraints]: TConstraints[K] extends (infer TConstraint) ? TConstraint extends {
-  readonly kind: 'primary-key' | 'unique';
+  readonly kind: "primary-key" | "unique";
   readonly columns: infer TCandidate extends readonly unknown[];
 } ? TColumns extends readonly unknown[] ? SameColumnTuple<TColumns, TCandidate> : false : false : false; }[keyof TConstraints] ? true : false : false;
 type HasMatchingIndex<TColumns, TIndexes> = TIndexes extends SourceIndexesRecord ? true extends { [K in keyof TIndexes]: TIndexes[K] extends (infer TIndex) ? TIndex extends {
   readonly terms: infer TTerms extends readonly IndexTerm[];
   readonly candidateKey: infer TCandidateKey;
 } ? [TCandidateKey] extends [true] ? TColumns extends readonly unknown[] ? SameColumnTuple<TColumns, IndexColumns<TTerms>> : false : false : false : false; }[keyof TIndexes] ? true : false : false;
-type TargetMetadata<TTarget extends ForeignKeyTarget, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = [SourceIdentity<TTarget['table']>] extends [TableIdentity<TName>] ? [TableIdentity<TName>] extends [SourceIdentity<TTarget['table']>] ? readonly [TConstraints, TIndexes] : readonly [ConstraintsOf<TTarget['table']>, IndexesOf<TTarget['table']>] : readonly [ConstraintsOf<TTarget['table']>, IndexesOf<TTarget['table']>];
-type InvalidForeignKey<TConstraint extends ForeignKeyConstraint, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = ResolvedTarget<TConstraint['target']> extends (infer TTarget) ? TTarget extends ForeignKeyTarget ? Exclude<DependenciesOf<TTarget['columns'][number]>, ColumnDependency<SourceIdentity<TTarget['table']>, string>> extends never ? TargetMetadata<TTarget, TName, TConstraints, TIndexes> extends readonly [infer TTargetConstraints, infer TTargetIndexes] ? HasMatchingConstraint<TTarget['columns'], TTargetConstraints> extends true ? never : HasMatchingIndex<TTarget['columns'], TTargetIndexes> extends true ? never : TConstraint : TConstraint : TConstraint : TConstraint : TConstraint;
+type TargetMetadata<TTarget extends ForeignKeyTarget, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = [SourceIdentity<TTarget["table"]>] extends [TableIdentity<TName>] ? [TableIdentity<TName>] extends [SourceIdentity<TTarget["table"]>] ? readonly [TConstraints, TIndexes] : readonly [ConstraintsOf<TTarget["table"]>, IndexesOf<TTarget["table"]>] : readonly [ConstraintsOf<TTarget["table"]>, IndexesOf<TTarget["table"]>];
+type InvalidForeignKey<TConstraint extends ForeignKeyConstraint, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = ResolvedTarget<TConstraint["target"]> extends (infer TTarget) ? TTarget extends ForeignKeyTarget ? Exclude<DependenciesOf<TTarget["columns"][number]>, ColumnDependency<SourceIdentity<TTarget["table"]>, string>> extends never ? TargetMetadata<TTarget, TName, TConstraints, TIndexes> extends readonly [infer TTargetConstraints, infer TTargetIndexes] ? HasMatchingConstraint<TTarget["columns"], TTargetConstraints> extends true ? never : HasMatchingIndex<TTarget["columns"], TTargetIndexes> extends true ? never : TConstraint : TConstraint : TConstraint : TConstraint : TConstraint;
 type InvalidConstraint<TConstraint, TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = TConstraint extends ForeignKeyConstraint ? InvalidForeignKey<TConstraint, TName, TConstraints, TIndexes> : TConstraint extends CheckConstraint<infer TExpression> ? InvalidExpression<TExpression, TName> : never;
 type InvalidConstraints<TName extends string, TConstraints extends SourceConstraintsRecord, TIndexes extends SourceIndexesRecord> = TConstraints[keyof TConstraints] extends (infer TConstraint) ? InvalidConstraint<TConstraint, TName, TConstraints, TIndexes> : never;
 type InvalidIndex<TIndex, TName extends string> = TIndex extends {
@@ -3644,7 +3631,7 @@ declare function table<const TName extends string, const TDefinitions extends Ta
 //#endregion
 //#region src/schema/source.d.ts
 declare const sourceIdentity: unique symbol;
-type SourceKind = 'table' | 'table-alias' | 'query-alias' | 'lateral' | 'cte' | 'excluded' | 'custom' | 'table-function';
+type SourceKind = "table" | "table-alias" | "query-alias" | "lateral" | "cte" | "excluded" | "custom" | "table-function";
 /** SQL semantic domains keyed by the application fields of a source row. */
 type SourceSqlTypes<TRow extends object> = { readonly [K in keyof TRow]: AnySqlType; };
 /** A source SQL-domain map used when no stronger metadata was declared. */
@@ -3659,11 +3646,11 @@ interface SourceConfig {
   readonly constraints?: SourceConstraintsRecord;
 }
 type SourceConfigValue<TConfig, TKey extends PropertyKey, TFallback> = TKey extends keyof TConfig ? TConfig[TKey] : TFallback;
-type SourceConfigIdentity<TConfig> = SourceConfigValue<TConfig, 'identity', unknown>;
-type SourceConfigRow<TConfig> = Extract<SourceConfigValue<TConfig, 'row', Record<string, unknown>>, object>;
-type SourceConfigMetadata<TConfig> = SourceConfigValue<TConfig, 'metadata', never>;
-type SourceConfigSqlTypes<TConfig> = Extract<SourceConfigValue<TConfig, 'sqlTypes', UnknownSourceSqlTypes<SourceConfigRow<TConfig>>>, SourceSqlTypes<SourceConfigRow<TConfig>>>;
-type SourceConfigConstraints<TConfig> = Extract<SourceConfigValue<TConfig, 'constraints', {}>, SourceConstraintsRecord>;
+type SourceConfigIdentity<TConfig> = SourceConfigValue<TConfig, "identity", unknown>;
+type SourceConfigRow<TConfig> = Extract<SourceConfigValue<TConfig, "row", Record<string, unknown>>, object>;
+type SourceConfigMetadata<TConfig> = SourceConfigValue<TConfig, "metadata", never>;
+type SourceConfigSqlTypes<TConfig> = Extract<SourceConfigValue<TConfig, "sqlTypes", UnknownSourceSqlTypes<SourceConfigRow<TConfig>>>, SourceSqlTypes<SourceConfigRow<TConfig>>>;
+type SourceConfigConstraints<TConfig> = Extract<SourceConfigValue<TConfig, "constraints", {}>, SourceConstraintsRecord>;
 interface Source<TConfig extends SourceConfig = {}> extends Fragment<ResultMeta<readonly SourceConfigRow<TConfig>[]> | ProvidesSourceMeta<SourceConfigIdentity<TConfig>, SourceConfigRow<TConfig>> | SourceConfigMetadata<TConfig>> {
   /** @internal Type-level configuration retained for inference. */
   readonly __sourceConfig?: TConfig;
@@ -3678,7 +3665,7 @@ interface Source<TConfig extends SourceConfig = {}> extends Fragment<ResultMeta<
 type AnySource = Source<any>;
 /** The source-provision fact carried by a source-producing fragment. */
 type SourceProvision<T> = Extract<MetadataOf<T>, {
-  readonly kind: 'provides-source';
+  readonly kind: "provides-source";
 }>;
 type ProvidedSourceIdentity<T> = SourceProvision<T> extends ProvidesSourceMeta<infer TIdentity, any> ? TIdentity : never;
 type ProvidedSourceRow<T> = SourceProvision<T> extends ProvidesSourceMeta<any, infer TRow> ? TRow : never;
@@ -3723,21 +3710,20 @@ declare function createSource<TIdentity, TRow extends object, TMetadata = never,
   readonly constraints: TConstraints;
 }>;
 /**
- * Create a typed source-producing fragment for a custom FROM relation such as
- * a table-valued function. The renderer owns the relation syntax and may bind
- * values through context.parameter(); the source identity and output columns
- * remain available to the normal FROM/JOIN scope checks.
+ * Create a typed source-producing fragment for a custom FROM relation such as a table-valued
+ * function. The renderer owns the relation syntax and may bind values through context.parameter();
+ * the source identity and output columns remain available to the normal FROM/JOIN scope checks.
  */
 declare function customSource<const TIdentity, const TDefinitions extends TableDefinitions>(options: CustomSourceOptions<TIdentity, TDefinitions>): CustomSource<TIdentity, TDefinitions>;
 /**
- * Add convenient direct column properties without allowing a column name to
- * overwrite the source's rendering or metadata primitives.
+ * Add convenient direct column properties without allowing a column name to overwrite the source's
+ * rendering or metadata primitives.
  */
 declare function exposeColumns(target: object, columns: Record<string, unknown>): void;
 //#endregion
 //#region src/query/types.d.ts
 type Row = Record<string, unknown>;
-type QueryKind = 'select' | 'set' | 'insert' | 'update' | 'delete';
+type QueryKind = "select" | "set" | "insert" | "update" | "delete";
 /** Sparse type-level configuration carried by a query. */
 interface QueryConfig {
   readonly row?: object;
@@ -3746,11 +3732,11 @@ interface QueryConfig {
   readonly sqlTypes?: unknown;
 }
 type QueryConfigValue<TConfig, TKey extends PropertyKey, TFallback> = TKey extends keyof TConfig ? TConfig[TKey] : TFallback;
-type QueryConfigRow<TConfig> = Extract<QueryConfigValue<TConfig, 'row', Row>, object>;
-type QueryConfigCardinality<TConfig> = Extract<QueryConfigValue<TConfig, 'cardinality', QueryCardinality>, QueryCardinality>;
-type QueryConfigMetadata<TConfig> = QueryConfigValue<TConfig, 'metadata', never>;
-type QueryConfigSqlTypes<TConfig> = QueryConfigValue<TConfig, 'sqlTypes', SourceSqlTypes<QueryConfigRow<TConfig>>>;
-interface Query$1<TConfig extends QueryConfig = {}> extends Fragment<ResultMeta<readonly QueryConfigRow<TConfig>[]> | CardinalityMeta<QueryConfigCardinality<TConfig>> | QueryConfigMetadata<TConfig>> {
+type QueryConfigRow<TConfig> = Extract<QueryConfigValue<TConfig, "row", Row>, object>;
+type QueryConfigCardinality<TConfig> = Extract<QueryConfigValue<TConfig, "cardinality", QueryCardinality>, QueryCardinality>;
+type QueryConfigMetadata<TConfig> = QueryConfigValue<TConfig, "metadata", never>;
+type QueryConfigSqlTypes<TConfig> = QueryConfigValue<TConfig, "sqlTypes", SourceSqlTypes<QueryConfigRow<TConfig>>>;
+interface Query<TConfig extends QueryConfig = {}> extends Fragment<ResultMeta<readonly QueryConfigRow<TConfig>[]> | CardinalityMeta<QueryConfigCardinality<TConfig>> | QueryConfigMetadata<TConfig>> {
   /** @internal Type-level configuration retained for inference. */
   readonly __queryConfig?: TConfig;
   readonly queryKind: QueryKind;
@@ -3760,8 +3746,8 @@ interface Query$1<TConfig extends QueryConfig = {}> extends Fragment<ResultMeta<
   /** Type-only SQL domains of the named query projection. */
   readonly sqlTypes?: QueryConfigSqlTypes<TConfig>;
 }
-type AnyQuery = Query$1<any>;
-type QueryWithRow<TRow extends object> = Query$1<{
+type AnyQuery = Query<any>;
+type QueryWithRow<TRow extends object> = Query<{
   readonly row: TRow;
   readonly cardinality: any;
   readonly metadata: any;
@@ -3778,33 +3764,33 @@ type QuerySqlTypeMap<T> = T extends {
 //#endregion
 //#region src/core/dialect.d.ts
 /** Capabilities whose syntax must be explicitly supported by a dialect. */
-type DialectCapability = 'ilike' | 'json' | 'on-conflict' | 'row-locking';
+type DialectCapability = "ilike" | "json" | "on-conflict" | "row-locking";
 /**
- * Optional dialect hook used by schema expressions when a JavaScript value
- * must become SQL text instead of a query parameter.
+ * Optional dialect hook used by schema expressions when a JavaScript value must become SQL text
+ * instead of a query parameter.
  *
- * The hook is deliberately separate from {@link Dialect.placeholder}: schema
- * metadata is parameter-free and must never render a query placeholder.
+ * The hook is deliberately separate from {@link Dialect.placeholder}: schema metadata is
+ * parameter-free and must never render a query placeholder.
  */
 type SchemaLiteralRenderer = (value: unknown) => string;
 /** Scalar application types supported by the portable JSON renderer. */
-type JsonScalarKind = 'text' | 'number' | 'boolean';
+type JsonScalarKind = "text" | "number" | "boolean";
 /** Dialect policy for portable scalar JSON reads and path existence checks. */
 interface DialectJson {
   renderScalar(context: RenderContext, document: AnyFragment, path: readonly (string | number)[], kind: JsonScalarKind): void;
   renderExists(context: RenderContext, document: AnyFragment, path: readonly (string | number)[]): void;
 }
-type PaginationKind = 'offset' | 'fetch';
+type PaginationKind = "offset" | "fetch";
 /** Logical built-in targets that a dialect can spell in CAST expressions. */
-type PortableCastType = 'integer' | 'decimal' | 'text' | 'boolean' | 'date' | 'timestamp' | 'uuid' | 'json' | 'bigint' | 'binary';
+type PortableCastType = "integer" | "decimal" | "text" | "boolean" | "date" | "timestamp" | "uuid" | "json" | "bigint" | "binary";
 /** A logical cast target whose concrete spelling is selected by a dialect. */
 interface PortableCastTarget<TType extends PortableCastType = PortableCastType> {
-  readonly kind: 'portable-cast';
+  readonly kind: "portable-cast";
   readonly type: TType;
 }
 /** A trusted raw cast target supplied by a custom definition. */
 interface NamedCastTarget<TTypeName extends string = string> {
-  readonly kind: 'named-cast';
+  readonly kind: "named-cast";
   readonly typeName: TTypeName;
 }
 /** Runtime target carried by a definition that can be used with cast(). */
@@ -3814,20 +3800,20 @@ type DialectCastTypes = Readonly<Partial<Record<PortableCastType, string>>>;
 interface PaginationPart {
   readonly kind: PaginationKind;
   readonly rows: number;
-  readonly direction?: 'FIRST' | 'NEXT';
+  readonly direction?: "FIRST" | "NEXT";
 }
 interface DialectPagination {
   /** Render a complete pagination group in dialect-specific syntax. */
   readonly render: (context: RenderContext, parts: readonly PaginationPart[]) => void;
 }
-type RowLockMode = 'update' | 'no-key-update' | 'share' | 'key-share';
-type RowLockWaitPolicy = 'default' | 'nowait' | 'skip-locked';
+type RowLockMode = "update" | "no-key-update" | "share" | "key-share";
+type RowLockWaitPolicy = "default" | "nowait" | "skip-locked";
 interface DialectRowLocking {
   /** Render a dialect-supported row-locking clause. */
   readonly render: (context: RenderContext, mode: RowLockMode, wait: RowLockWaitPolicy) => void;
 }
 /** Output modes accepted by first-party EXPLAIN policies. */
-type ExplainFormat = 'text' | 'json' | 'xml' | 'yaml' | 'tree' | 'traditional' | 'query-plan' | 'bytecode';
+type ExplainFormat = "text" | "json" | "xml" | "yaml" | "tree" | "traditional" | "query-plan" | "bytecode";
 /** Dialect-independent EXPLAIN switches passed to a dialect policy. */
 interface ExplainRenderOptions {
   readonly analyze?: boolean;
@@ -3859,7 +3845,7 @@ interface Dialect<TCapabilities extends DialectCapability = DialectCapability> {
   /** Capabilities advertised by this dialect at the rendering boundary. */
   readonly capabilities?: readonly TCapabilities[];
 }
-interface DialectOptions<TCapabilities extends Exclude<DialectCapability, 'json'> = never, TJson extends DialectJson | undefined = DialectJson | undefined> {
+interface DialectOptions<TCapabilities extends Exclude<DialectCapability, "json"> = never, TJson extends DialectJson | undefined = DialectJson | undefined> {
   readonly name: string;
   readonly quoteIdentifier?: (identifier: string) => string;
   readonly placeholder: (position: number) => string;
@@ -3878,16 +3864,16 @@ interface DialectOptions<TCapabilities extends Exclude<DialectCapability, 'json'
 /** Resolve a logical or explicitly named CAST target for a dialect. */
 declare function resolveCastTarget(dialect: Dialect, target: CastTarget): string;
 /**
- * Create a dialect from the few rendering decisions that SQL builders need
- * to leave open. More involved syntax can be supplied as a custom fragment.
+ * Create a dialect from the few rendering decisions that SQL builders need to leave open. More
+ * involved syntax can be supplied as a custom fragment.
  */
-declare function createDialect<const TCapabilities extends Exclude<DialectCapability, 'json'> = never>(options: DialectOptions<TCapabilities, DialectJson> & {
+declare function createDialect<const TCapabilities extends Exclude<DialectCapability, "json"> = never>(options: DialectOptions<TCapabilities, DialectJson> & {
   readonly json: DialectJson;
-}): Dialect<TCapabilities | 'json'>;
-declare function createDialect<const TCapabilities extends Exclude<DialectCapability, 'json'> = never>(options: DialectOptions<TCapabilities, undefined>): Dialect<TCapabilities>;
+}): Dialect<TCapabilities | "json">;
+declare function createDialect<const TCapabilities extends Exclude<DialectCapability, "json"> = never>(options: DialectOptions<TCapabilities, undefined>): Dialect<TCapabilities>;
 /**
- * Check a capability at runtime for callers that intentionally bypass the
- * typed render boundary or use a dialect supplied by an older integration.
+ * Check a capability at runtime for callers that intentionally bypass the typed render boundary or
+ * use a dialect supplied by an older integration.
  */
 declare function assertDialectCapability(dialect: Dialect, capability: DialectCapability): void;
 //#endregion
@@ -3914,7 +3900,7 @@ interface SnapshotNamingPolicy {
 }
 /** A JSON-safe representation of a non-finite JavaScript number. */
 interface SnapshotSpecialNumber {
-  readonly $number: 'NaN' | 'Infinity' | '-Infinity';
+  readonly $number: "NaN" | "Infinity" | "-Infinity";
 }
 /** A JSON-safe representation of a JavaScript bigint. */
 interface SnapshotBigInt {
@@ -3932,18 +3918,18 @@ interface SnapshotDialectExtension {
 }
 /** A portable or dialect-owned physical column declaration. */
 type SnapshotStorage = {
-  readonly kind: 'portable';
+  readonly kind: "portable";
   readonly type: string;
 } | {
-  readonly kind: 'native';
+  readonly kind: "native";
   readonly dialect: string;
   readonly type: string;
   /** SQLite's derived type affinity, when the selected adapter records it. */
-  readonly affinity?: 'blob' | 'integer' | 'numeric' | 'real' | 'text';
+  readonly affinity?: "blob" | "integer" | "numeric" | "real" | "text";
 };
 /** A deterministic expression after it crosses the snapshot data boundary. */
 interface SnapshotExpression {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expressionKind: string;
   /** Canonical parameter-free text for the selected schema expression dialect. */
   readonly sql: string;
@@ -3952,42 +3938,42 @@ interface SnapshotExpression {
 }
 /** A default value retained independently from insert-write behavior. */
 type SnapshotDefault = {
-  readonly kind: 'literal';
+  readonly kind: "literal";
   readonly value: SnapshotLiteral;
 } | {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expression: SnapshotExpression;
 } | {
-  readonly kind: 'external';
+  readonly kind: "external";
 };
 /** Canonical literal values accepted by neutral schema metadata. */
 type SnapshotLiteral = {
-  readonly kind: 'null';
+  readonly kind: "null";
 } | {
-  readonly kind: 'boolean';
+  readonly kind: "boolean";
   readonly value: boolean;
 } | {
-  readonly kind: 'string';
+  readonly kind: "string";
   readonly value: string;
 } | {
-  readonly kind: 'number';
+  readonly kind: "number";
   readonly value: string;
 } | {
-  readonly kind: 'bigint';
+  readonly kind: "bigint";
   readonly value: string;
 };
 /** A generated-column expression and its storage mode. */
 type SnapshotGeneratedColumn = {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expression: SnapshotExpression;
-  readonly mode: 'stored' | 'virtual';
+  readonly mode: "stored" | "virtual";
 } | {
-  readonly kind: 'external';
+  readonly kind: "external";
 };
 /** Identity behavior is deliberately separate from generated expressions. */
 interface SnapshotIdentity {
-  readonly kind: 'identity';
-  readonly generation: 'always' | 'by-default';
+  readonly kind: "identity";
+  readonly generation: "always" | "by-default";
   readonly dialect?: SnapshotDialectExtension;
 }
 /** A canonical column record keyed by its stable logical field ID. */
@@ -4006,65 +3992,65 @@ interface SnapshotColumn {
 }
 /** An expression or bare column used by an index. */
 type SnapshotIndexTermExpression = {
-  readonly kind: 'column';
+  readonly kind: "column";
   readonly column: string;
 } | {
-  readonly kind: 'expression';
+  readonly kind: "expression";
   readonly expression: SnapshotExpression;
 };
 /** One ordered index term. */
 type SnapshotIndexTerm = SnapshotIndexTermExpression | {
-  readonly kind: 'order';
+  readonly kind: "order";
   readonly expression: SnapshotIndexTermExpression;
-  readonly direction?: 'ASC' | 'DESC';
-  readonly nulls?: 'FIRST' | 'LAST';
+  readonly direction?: "ASC" | "DESC";
+  readonly nulls?: "FIRST" | "LAST";
 };
 /** Common key metadata shared by primary and strict unique constraints. */
 interface SnapshotKeyConstraint {
   readonly id: string;
-  readonly kind: 'primary-key' | 'unique';
+  readonly kind: "primary-key" | "unique";
   readonly physicalName: string;
   readonly columns: readonly string[];
   readonly deferrable?: boolean;
-  readonly initially?: 'immediate' | 'deferred';
+  readonly initially?: "immediate" | "deferred";
   readonly dialect?: SnapshotDialectExtension;
 }
 /** Nullable database uniqueness, intentionally not a candidate-key proof. */
 interface SnapshotUniqueConstraint {
   readonly id: string;
-  readonly kind: 'unique-constraint';
+  readonly kind: "unique-constraint";
   readonly physicalName: string;
   readonly columns: readonly string[];
-  readonly nulls: 'distinct' | 'not-distinct';
+  readonly nulls: "distinct" | "not-distinct";
   readonly deferrable?: boolean;
-  readonly initially?: 'immediate' | 'deferred';
+  readonly initially?: "immediate" | "deferred";
   readonly dialect?: SnapshotDialectExtension;
 }
 /** A foreign key whose target is represented only by logical IDs. */
 interface SnapshotForeignKey {
   readonly id: string;
-  readonly kind: 'foreign-key';
+  readonly kind: "foreign-key";
   readonly physicalName: string;
   readonly columns: readonly string[];
   readonly target: {
     readonly table: string;
     readonly columns: readonly string[];
   };
-  readonly onUpdate?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
-  readonly onDelete?: 'no-action' | 'restrict' | 'cascade' | 'set-null' | 'set-default';
-  readonly match?: 'simple' | 'full' | 'partial';
+  readonly onUpdate?: "no-action" | "restrict" | "cascade" | "set-null" | "set-default";
+  readonly onDelete?: "no-action" | "restrict" | "cascade" | "set-null" | "set-default";
+  readonly match?: "simple" | "full" | "partial";
   readonly deferrable?: boolean;
-  readonly initially?: 'immediate' | 'deferred';
+  readonly initially?: "immediate" | "deferred";
   readonly dialect?: SnapshotDialectExtension;
 }
 /** A table check constraint with a detached expression value. */
 interface SnapshotCheckConstraint {
   readonly id: string;
-  readonly kind: 'check';
+  readonly kind: "check";
   readonly physicalName: string;
   readonly expression: SnapshotExpression;
   readonly deferrable?: boolean;
-  readonly initially?: 'immediate' | 'deferred';
+  readonly initially?: "immediate" | "deferred";
   readonly dialect?: SnapshotDialectExtension;
 }
 /** Every constraint represented by the v1 neutral model. */
@@ -4072,7 +4058,7 @@ type SnapshotConstraint = SnapshotKeyConstraint | SnapshotUniqueConstraint | Sna
 /** A canonical index record keyed by its stable logical ID. */
 interface SnapshotIndex {
   readonly id: string;
-  readonly kind: 'index';
+  readonly kind: "index";
   readonly physicalName: string;
   readonly terms: readonly SnapshotIndexTerm[];
   readonly unique: boolean;
@@ -4100,7 +4086,7 @@ interface SchemaSnapshot {
 }
 /** Schema-expression context supplied to a dialect adapter. */
 interface SnapshotExpressionContext {
-  readonly mode: 'default' | 'generated' | 'check' | 'index';
+  readonly mode: "default" | "generated" | "check" | "index";
   readonly path: readonly (string | number)[];
   readonly dialect: SchemaDialect;
 }
@@ -4120,17 +4106,16 @@ interface SnapshotValidationContext {
   readonly dialect: SchemaDialect;
 }
 /**
- * Adapter boundary for the common traversal. Schema hooks live on
- * `dialect.schema`; the adapter only selects that schema dialect, so
- * PostgreSQL, SQLite, and MySQL can share the query rendering policy without
- * taking ownership of canonical ordering or cross-reference validation.
+ * Adapter boundary for the common traversal. Schema hooks live on `dialect.schema`; the adapter
+ * only selects that schema dialect, so PostgreSQL, SQLite, and MySQL can share the query rendering
+ * policy without taking ownership of canonical ordering or cross-reference validation.
  */
 interface SchemaSnapshotAdapter<TCapabilities extends DialectCapability = DialectCapability> {
   /** The query dialect plus its schema hooks and metadata. */
   readonly dialect: SchemaDialect<TCapabilities>;
 }
 /** Structured diagnostic categories emitted by snapshot tooling. */
-type SnapshotDiagnosticCode = 'invalid-schema' | 'invalid-value' | 'unsupported-expression' | 'dialect-mismatch' | 'unresolved-reference' | 'invalid-snapshot' | 'unknown-field' | 'future-version' | 'invalid-cross-reference' | 'non-canonical' | 'unsupported-dialect-option';
+type SnapshotDiagnosticCode = "invalid-schema" | "invalid-value" | "unsupported-expression" | "dialect-mismatch" | "unresolved-reference" | "invalid-snapshot" | "unknown-field" | "future-version" | "invalid-cross-reference" | "non-canonical" | "unsupported-dialect-option";
 /** A path-addressed snapshot diagnostic suitable for CLI or editor output. */
 interface SnapshotDiagnostic {
   readonly code: SnapshotDiagnosticCode;
@@ -4159,4 +4144,4 @@ type SchemaSnapshotInput = SchemaSnapshot | Readonly<Record<string, unknown>>;
 /** Expose the schema generic in tooling declarations without widening APIs. */
 type AnySchema = Schema<any>;
 //#endregion
-export { PaginationKind as $, ExecutionRequest as $a, SchemaObjectNameOptions as $c, rank as $i, InheritedMetadata as $l, AvailableScope as $n, ForeignKeyTargetInput as $o, unsafeSchemaSql as $r, PortableStorageType as $s, PostgresIndexExtension as $t, SnapshotStorage as A, lt as Aa, ExternalGeneratedColumnDescriptor as Ac, RowLockOptions as Ai, ResultField as Al, excluded as An, stream as Ao, groupBy as Ar, ColumnInsertInput as As, SourceSqlTypeMap as At, SqlBoolean as Au, CastTarget as B, Operand as Ba, SchemaLiteralValue as Bc, add as Bi, CapabilityMetadataOf as Bl, MutationReturning as Bn, CatalogCheckExpression as Bo, SchemaExpressionError as Br, ColumnStorageDialectOf as Bs, TableDefinitions as Bt, SqlSemanticType as Bu, SnapshotIndexTerm as C, ComparisonValidation as Ca, ColumnBehaviorErrorCode as Cc, or as Ci, markExpressionCategory as Cl, ConflictTarget as Cn, StreamingTransactionalQueryAdapter as Co, from as Cr, ColumnDefaultOf as Cs, SourceColumns as Ct, fragment as Cu, SnapshotLiteral as D, isDistinctFrom as Da, ExpressionDefaultDescriptor as Dc, omit as Di, ResultDecoder as Dl, OnConflictClause as Dn, executeRows as Do, leftJoin as Dr, ColumnGeneratedOf as Ds, SourceKind as Dt, AnySqlType as Du, SnapshotKeyConstraint as E, gte as Ea, DefaultDescriptor as Ec, SelectPart as Ei, ResultDecodeContext as El, ExcludedSource as En, execute as Eo, innerJoin as Er, ColumnFromOptions as Es, SourceIdentity as Et, sequence as Eu, neutralSnapshotDialect as F, inList as Fa, IdentityDialectExtension as Fc, having as Fi, timestampResultDecoder as Fl, AllowAllClause as Fn, QueryTypeValidation as Fo, all as Fr, ColumnOutput as Fs, exposeColumns as Ft, SqlInteger as Fu, DialectJson as G, typedValue as Ga, generatedColumn as Gc, JsonPath as Gi, Fragment as Gl, allowAll as Gn, ConstraintOptions as Go, SchemaRenderOptions as Gr, ColumnUpdateInput as Gs, TableRow as Gt, SqlUnknown as Gu, DialectCapability as H, OperandSqlType as Ha, canonicalLiteral as Hc, modulo as Hi, CardinalityOf as Hl, MutationRow as Hn, CheckConstraint as Ho, SchemaExpressionInput as Hr, ColumnStorageOf as Hs, TableInsertInput as Ht, SqlTextLike as Hu, schemaSnapshotDialectVersion as I, notIn as Ia, IdentityGeneration as Ic, distinct as Ii, AggregateDependenciesOf as Il, MutationClause as In, QueryValidationError as Io, SchemaDialect as Ir, ColumnSqlType as Is, sourceIdentity as It, SqlJson as Iu, DialectRowLocking as J, cast as Ja, SchemaDialectExtension as Jc, jsonNumber as Ji, GroupingKeysOf as Jl, ReturningSqlTypes as Jn, FieldLikeOptions as Jo, isUnsafeSchemaSql as Jr, NativeStorage as Js, table as Jt, DialectOptions as K, value as Ka, identityColumn as Kc, jsonBoolean as Ki, FragmentMeta as Kl, ReturningClause as Kn, ConstraintTiming as Ko, UnsafeSchemaSqlExpression as Kr, DialectNativeStorage as Ks, TableSqlTypes as Kt, SqlUuid as Ku, schemaSnapshotFormat as L, isNotNull as La, LiteralDefaultDescriptor as Lc, AnySelectClause as Li, AggregateMeta as Ll, MutationKind as Ln, QueryValidationErrorCode as Lo, SchemaDialectHooks as Lr, ColumnStorage as Ls, AnyTable as Lt, SqlNumericLike as Lu, SnapshotTable as M, ne as Ma, GeneratedColumnMode as Mc, fetchFirst as Mi, booleanResultDecoder as Ml, UpdateAssignmentValue as Mn, RenderOptions as Mo, SelectionObject as Mr, ColumnIsNullable as Ms, UnknownSourceSqlTypes as Mt, SqlDecimal as Mu, SnapshotUniqueConstraint as N, notLike as Na, GeneratedDescriptor as Nc, fetchNext as Ni, dateResultDecoder as Nl, UpdateAssignments as Nn, RenderedQuery as No, SelectionOutput as Nr, ColumnOnUpdateOf as Ns, createSource as Nt, SqlEqualityComparable as Nu, SnapshotNamingPolicy as O, isNotDistinctFrom as Oa, ExpressionGeneratedColumnDescriptor as Oc, where as Oi, ResultDecoders as Ol, doNothing as On, explain as Oo, naturalJoin as Or, ColumnHasDefault as Os, SourceProvision as Ot, SqlBigInt as Ou, SnapshotValidationContext as P, between as Pa, IdentityDescriptor as Pc, offset as Pi, jsonTextResultDecoder as Pl, update as Pn, render as Po, SelectionSqlTypes as Pr, ColumnOptions as Ps, customSource as Pt, SqlEqualityCompatible as Pu, NamedCastTarget as Q, ExecutionOptions as Qa, SchemaObjectIdentity as Qc, over as Qi, HasWindow as Ql, AvailableOuterScope as Qn, ForeignKeyTarget as Qo, schemaExpression as Qr, PortableStorageDescriptor as Qs, MysqlIndexExtension as Qt, schemaSnapshotNamingPolicyVersion as R, isNull as Ra, MysqlIdentityExtension as Rc, ClausePlacement as Ri, AnyFragment as Rl, MutationQuery as Rn, QueryValidationIssue as Ro, createSchemaDialect as Rr, ColumnStorageDeclarationOf as Rs, Table as Rt, SqlOrderCompatible as Ru, SnapshotIndex as S, scalar as Sa, ColumnBehaviorError as Sc, not as Si, makeExpression as Sl, ConflictAction as Sn, StreamingQueryAdapter as So, FromSource as Sr, DeclaredColumnNullability as Ss, Source as St, WindowMeta as Su, SnapshotJsonValue as T, gt as Ta, ColumnDefaultInput as Tc, OmittableSelectClause as Ti, DecodableResultType as Tl, DoUpdateAction as Tn, TransactionalQueryAdapter as To, fullJoin as Tr, ColumnDefinitionConfig as Ts, SourceConstraints as Tt, parenthesize as Tu, DialectCastTypes as U, SqlCapabilityValidation as Ua, externalDefault as Uc, multiply as Ui, DependenciesOf as Ul, MutationScopeValidation as Un, CheckConstraintOptions as Uo, SchemaExpressionMode as Ur, ColumnStorageType as Us, TableMetadataCallback as Ut, SqlTimestamp as Uu, Dialect as V, OperandNullability as Va, SqliteIdentityExtension as Vc, divide as Vi, CardinalityMeta as Vl, MutationReturningClause as Vn, CatalogCheckSql as Vo, SchemaExpressionErrorCode as Vr, ColumnStorageKindOf as Vs, TableIdentity as Vt, SqlText as Vu, DialectExplain as W, asValue as Wa, externalGeneratedColumn as Wc, subtract as Wi, ExpressionMeta as Wl, MutationSqlTypes as Wn, ConstraintDialectExtension as Wo, SchemaRenderContext as Wr, ColumnStorageTypeOf as Ws, TableOptions as Wt, SqlTypeSatisfies as Wu, ExplainRenderOptions as X, AdapterExecutionResult as Xa, SchemaMetadataDiagnostic as Xc, jsonText as Xi, HasAggregate as Xl, correlate as Xn, ForeignKeyMatch as Xo, renderSchemaExpression as Xr, PortableColumnStorage as Xs, IndexOptions as Xt, ExplainFormat as Y, typedCast as Ya, SchemaDialectName as Yc, jsonPath as Yi, GroupingMeta as Yl, returning as Yn, ForeignKeyConstraint as Yo, normalizeSchemaSql as Yr, NativeStorageDescriptor as Ys, IndexDialectExtension as Yt, JsonScalarKind as Z, DriverValueEncoder as Za, SchemaMetadataValidationError as Zc, denseRank as Zi, HasSubquery as Zl, select as Zn, ForeignKeyOptions as Zo, renderSchemaSql as Zr, PortableStorage as Zs, IndexTerm as Zt, SnapshotExpressionContext as _, sql as _a, portableStorage as _c, QueryAliasIdentity as _i, ExpressionSqlType as _l, ValuesSource as _n, QubuTransaction as _o, intersect as _r, primaryKey as _s, AnySource as _t, RequiresSourceMeta as _u, SnapshotBigInt as a, call as aa, bigint as ac, SchemaTableNames as ai, materializeSchemaObjectIdentity as al, validateIndexDialect as an, ExplainReadOptions as ao, ScopeValidation as ar, SourceConstraint as as, SchemaLiteralRenderer as at, OutputOf as au, SnapshotGeneratedColumn as b, inQuery as ba, uuid as bc, lateral as bi, SchemaExpressionBrand as bl, insertSelect as bn, QueryExecutor as bo, FromClause as br, uniqueConstraint as bs, ProvidedSourceIdentity as bt, SubqueryMeta as bu, SnapshotConstraint as c, avg as ca, column as cc, SchemaValidationError as ci, ColumnReference as cl, desc as cn, ExplainableQueryAdapter as co, CteSource as cr, SqliteConstraintExtension as cs, resolveCastTarget as ct, ProvidesSourceMeta as cu, SnapshotDefault as d, max as da, integer as dc, schema as di, AnySchemaExpression as dl, order as dn, QubuExplainableStreamingTransactionalClient as do, cte as dr, UniqueConstraintOptions as ds, QueryConfig as dt, RenderFunction as du, rowNumber as ea, StorageDeclarationOf as ec, Schema as ei, assertSchemaDialectSupport as el, SourceIndex as en, ExecutionResult as eo, ClauseScope as er, KeyConstraint as es, PaginationPart as et, InheritedMetadataOf as eu, SnapshotDiagnostic as f, min as fa, json as fc, schemaNamingPolicyVersion as fi, Expression as fl, orderBy as fn, QubuExplainableTransactionalClient as fo, recursiveCte as fr, UniqueNullSemantics as fs, QueryKind as ft, RequiresCapabilityMeta as fu, SnapshotExpression as g, TypedSqlTag as ga, numeric as gc, LateralSource as gi, ExpressionRequires as gl, InsertSource as gn, QubuStreamingTransactionalClient as go, except as gr, foreignKey as gs, Row as gt, RequiresOuterSourceMeta as gu, SnapshotDialectExtension as h, SqlTag as ha, nullable as hc, LateralIdentity as hi, ExpressionOutput as hl, InsertSelectSource as hn, QubuStreamingTransaction as ho, SetQuery as hr, check as hs, QueryWithRow as ht, RequiresOuterOf as hu, SchemaSnapshotInput as i, upper as ia, StorageTypeOf as ic, SchemaTableEntry as ii, isValidSchemaObjectName as il, index as in, ExplainPlanRow as io, RequiredScope as ir, ReferentialAction as is, RowLockWaitPolicy as it, NullableSourcesOf as iu, SnapshotStorageContext as j, lte as ja, GeneratedColumnDescriptor as jc, rowLock as ji, ResultShape as jl, onConflict as jn, RenderCapabilityValidation as jo, Selection as jr, ColumnIsGenerated as js, SourceSqlTypes as jt, SqlDate as ju, SnapshotSpecialNumber as k, like as ka, ExternalDefaultDescriptor as kc, RowLockClause as ki, ResultDecodingError as kl, doUpdate as kn, qubu as ko, rightJoin as kr, ColumnIdentityOf as ks, SourceRow as kt, SqlBinary as ku, SnapshotCreateResult as l, count as la, columnResultValue as lc, defaultSchemaNamingPolicy as li, expressionFragment as ll, nullsFirst as ln, QubuClient as lo, RecursiveCteSource as lr, TableLike as ls, AnyQuery as lt, QueryCardinality as lu, SnapshotDialect as m, SqlFragment as ma, nativeStorage as mc, AliasedSource as mi, ExpressionNullability as ml, DefaultValuesSource as mn, QubuStreamingExplainableClient as mo, SetOperator as mr, catalogForeignKey as ms, QuerySqlTypeMap as mt, RequiresOuterMetadataOf as mu, SchemaSnapshot as n, concat as na, StorageDialectOf as nc, SchemaNamingPolicy as ni, freezeSchemaMetadata as nl, SqliteIndexExtension as nn, ExplainOptions as no, MissingScope as nr, MysqlConstraintExtension as ns, PortableCastType as nt, NullabilityOf as nu, SnapshotCheckConstraint as o, schemaCall as oa, binary as oc, SchemaTableRecord as oi, materializeSchemaObjectRecord as ol, OrderTerm as on, ExplainRequest as oo, SelectCardinality as or, SourceConstraintsRecord as os, assertDialectCapability as ot, ProvidesOuterOf as ou, SnapshotDiagnosticCode as p, sum as pa, nativeColumn as pc, AliasIdentity as pi, ExpressionKind as pl, deleteFrom as pn, QubuStreamingClient as po, withCte as pr, catalogCheck as ps, QueryRow as pt, RequiresOf as pu, DialectPagination as q, mapResult as qa, resolveColumnBehavior as qc, jsonExists as qi, GroupingDependenciesOf as ql, ReturningRow as qn, FieldLike as qo, defineSchemaExpression as qr, NativeColumnStorage as qs, TableUpdateInput as qt, SchemaSnapshotAdapter as r, lower as ra, StorageOf as rc, SchemaOptions as ri, generatedSchemaObjectName as rl, TableIndex as rn, ExplainOptionsFor as ro, RequiredOuterScope as rr, PostgresConstraintExtension as rs, RowLockMode as rt, NullableSourceMeta as ru, SnapshotColumn as s, typedCall as sa, boolean as sc, SchemaTableRegistry as si, ColumnDependency as sl, asc as sn, ExplainResult as so, SelectQuery as sr, SourceLike as ss, createDialect as st, ProvidesOuterSourceMeta as su, AnySchema as t, coalesce as ta, StorageDescriptor as tc, SchemaDiagnostic as ti, dialectMismatchDiagnostic as tl, SourceIndexesRecord as tn, ExplainMutationOptions as to, GroupingValidation as tr, KeyConstraintOptions as ts, PortableCastTarget as tt, MetadataOf as tu, SnapshotDecodeResult as u, countDistinct as ua, date as uc, generatedTableName as ui, AnyExpression as ul, nullsLast as un, QubuExplainableClient as uo, WithClause as ur, UniqueConstraint as us, Query$1 as ut, RenderContext as uu, SnapshotExtensionContext as v, caseWhen as va, text as vc, QuerySource as vi, ExpressionWithOutput as vl, defaultValues as vn, QubuTransactionalClient as vo, union as vr, references as vs, CustomSource as vt, ResultMeta as vu, SnapshotIndexTermExpression as w, eq as wa, ColumnDefault as wc, Omit$1 as wi, withDialectCapability as wl, DoNothingAction as wn, TransactionOptions as wo, crossJoin as wr, ColumnDefinition as ws, SourceConfig as wt, isFragment as wu, SnapshotIdentity as x, notExists as xa, CanonicalLiteral as xc, and as xi, isExpression as xl, values as xn, StreamableQuery as xo, FromScope as xr, validateConstraintDialect as xs, ProvidedSourceRow as xt, VisibleDependenciesOf as xu, SnapshotForeignKey as y, exists as ya, timestamp as yc, alias as yi, SchemaExpression as yl, insertInto as yn, QueryAdapter as yo, unionAll as yr, unique as ys, CustomSourceOptions as yt, SqlTypeOf as yu, schemaSnapshotVersion as z, isTrue as za, ResolvedColumnBehavior as zc, SelectClause as zi, CapabilitiesOf as zl, MutationQueryConfig as zn, AnyKeyColumn as zo, RenderedSchemaExpression as zr, ColumnStorageDescriptor as zs, TableColumns as zt, SqlOrderable as zu };
+export { PaginationKind as $, SqlTag as $a, RenderCapabilityValidation as $c, SourceIndexesRecord as $i, InheritedMetadata as $l, WithClause as $n, ColumnStorageOf as $o, generatedTableName as $r, canonicalLiteral as $s, nullsLast as $t, SnapshotStorage as A, jsonBoolean as Aa, ExplainableQueryAdapter as Ac, catalogCheck as Ai, ResultField as Al, MutationReturningClause as An, value as Ao, SchemaExpressionErrorCode as Ar, timestamp as As, SourceSqlTypeMap as At, SqlBoolean as Au, CastTarget as B, concat as Ba, QubuTransactionalClient as Bc, AliasedSource as Bi, CapabilityMetadataOf as Bl, select as Bn, ColumnIdentityOf as Bo, renderSchemaSql as Br, ExternalDefaultDescriptor as Bs, TableDefinitions as Bt, SqlSemanticType as Bu, SnapshotIndexTerm as C, SelectClause as Ca, ExplainMutationOptions as Cc, SourceConstraintsRecord as Ci, markExpressionCategory as Cl, update as Cn, isTrue as Co, SelectionSqlTypes as Cr, json as Cs, SourceColumns as Ct, fragment as Cu, SnapshotLiteral as D, multiply as Da, ExplainReadOptions as Dc, UniqueConstraint as Di, ResultDecoder as Dl, MutationQuery as Dn, SqlCapabilityValidation as Do, createSchemaDialect as Dr, numeric as Ds, SourceKind as Dt, AnySqlType as Du, SnapshotKeyConstraint as E, modulo as Ea, ExplainPlanRow as Ec, TableLike as Ei, ResultDecodeContext as El, MutationKind as En, OperandSqlType as Eo, SchemaDialectHooks as Er, nullable as Es, SourceIdentity as Et, sequence as Eu, neutralSnapshotDialect as F, denseRank as Fa, QubuStreamingClient as Fc, references as Fi, timestampResultDecoder as Fl, ReturningClause as Fn, ColumnDefinition as Fo, UnsafeSchemaSqlExpression as Fr, ColumnDefault as Fs, exposeColumns as Ft, SqlInteger as Fu, DialectJson as G, typedCall as Ga, StreamingTransactionalQueryAdapter as Gc, alias as Gi, Fragment as Gl, MissingScope as Gn, ColumnOptions as Go, SchemaNamingPolicy as Gr, IdentityDescriptor as Gs, TableRow as Gt, SqlUnknown as Gu, DialectCapability as H, upper as Ha, QueryExecutor as Hc, LateralSource as Hi, CardinalityOf as Hl, AvailableScope as Hn, ColumnIsGenerated as Ho, unsafeSchemaSql as Hr, GeneratedColumnDescriptor as Hs, TableInsertInput as Ht, SqlTextLike as Hu, schemaSnapshotDialectVersion as I, over as Ia, QubuStreamingExplainableClient as Ic, unique as Ii, AggregateDependenciesOf as Il, ReturningRow as In, ColumnDefinitionConfig as Io, defineSchemaExpression as Ir, ColumnDefaultInput as Is, sourceIdentity as It, SqlJson as Iu, DialectRowLocking as J, countDistinct as Ja, execute as Jc, IndexOptions as Ji, GroupingKeysOf as Jl, ScopeValidation as Jn, ColumnStorage as Jo, SchemaTableNames as Jr, LiteralDefaultDescriptor as Js, table as Jt, DialectOptions as K, avg as Ka, TransactionOptions as Kc, lateral as Ki, FragmentMeta as Kl, RequiredOuterScope as Kn, ColumnOutput as Ko, SchemaOptions as Kr, IdentityDialectExtension as Ks, TableSqlTypes as Kt, SqlUuid as Ku, schemaSnapshotFormat as L, rank as La, QubuStreamingTransaction as Lc, uniqueConstraint as Li, AggregateMeta as Ll, ReturningSqlTypes as Ln, ColumnFromOptions as Lo, isUnsafeSchemaSql as Lr, DefaultDescriptor as Ls, AnyTable as Lt, SqlNumericLike as Lu, SnapshotTable as M, jsonNumber as Ma, QubuExplainableClient as Mc, check as Mi, booleanResultDecoder as Ml, MutationScopeValidation as Mn, cast as Mo, SchemaExpressionMode as Mr, CanonicalLiteral as Ms, UnknownSourceSqlTypes as Mt, SqlDecimal as Mu, SnapshotUniqueConstraint as N, jsonPath as Na, QubuExplainableStreamingTransactionalClient as Nc, foreignKey as Ni, dateResultDecoder as Nl, MutationSqlTypes as Nn, typedCast as No, SchemaRenderContext as Nr, ColumnBehaviorError as Ns, createSource as Nt, SqlEqualityComparable as Nu, SnapshotNamingPolicy as O, subtract as Oa, ExplainRequest as Oc, UniqueConstraintOptions as Oi, ResultDecoders as Ol, MutationQueryConfig as On, asValue as Oo, RenderedSchemaExpression as Or, portableStorage as Os, SourceProvision as Ot, SqlBigInt as Ou, SnapshotValidationContext as P, jsonText as Pa, QubuExplainableTransactionalClient as Pc, primaryKey as Pi, jsonTextResultDecoder as Pl, allowAll as Pn, ColumnDefaultOf as Po, SchemaRenderOptions as Pr, ColumnBehaviorErrorCode as Ps, customSource as Pt, SqlEqualityCompatible as Pu, NamedCastTarget as Q, SqlFragment as Qa, stream as Qc, SourceIndex as Qi, HasWindow as Ql, RecursiveCteSource as Qn, ColumnStorageKindOf as Qo, defaultSchemaNamingPolicy as Qr, SqliteIdentityExtension as Qs, nullsFirst as Qt, schemaSnapshotNamingPolicyVersion as R, rowNumber as Ra, QubuStreamingTransactionalClient as Rc, validateConstraintDialect as Ri, AnyFragment as Rl, returning as Rn, ColumnGeneratedOf as Ro, normalizeSchemaSql as Rr, ExpressionDefaultDescriptor as Rs, Table as Rt, SqlOrderCompatible as Ru, SnapshotIndex as S, ClausePlacement as Sa, ExecutionResult as Sc, SourceConstraint as Si, makeExpression as Sl, UpdateAssignments as Sn, isNull as So, SelectionOutput as Sr, integer as Ss, Source as St, WindowMeta as Su, SnapshotJsonValue as T, divide as Ta, ExplainOptionsFor as Tc, SqliteConstraintExtension as Ti, DecodableResultType as Tl, MutationClause as Tn, OperandNullability as To, SchemaDialect as Tr, nativeStorage as Ts, SourceConstraints as Tt, parenthesize as Tu, DialectCastTypes as U, call as Ua, StreamableQuery as Uc, QueryAliasIdentity as Ui, DependenciesOf as Ul, ClauseScope as Un, ColumnIsNullable as Uo, Schema as Ur, GeneratedColumnMode as Us, TableMetadataCallback as Ut, SqlTimestamp as Uu, Dialect as V, lower as Va, QueryAdapter as Vc, LateralIdentity as Vi, CardinalityMeta as Vl, AvailableOuterScope as Vn, ColumnInsertInput as Vo, schemaExpression as Vr, ExternalGeneratedColumnDescriptor as Vs, TableIdentity as Vt, SqlText as Vu, DialectExplain as W, schemaCall as Wa, StreamingQueryAdapter as Wc, QuerySource as Wi, ExpressionMeta as Wl, GroupingValidation as Wn, ColumnOnUpdateOf as Wo, SchemaDiagnostic as Wr, GeneratedDescriptor as Ws, TableOptions as Wt, SqlTypeSatisfies as Wu, ExplainRenderOptions as X, min as Xa, explain as Xc, MysqlIndexExtension as Xi, HasAggregate as Xl, SelectQuery as Xn, ColumnStorageDescriptor as Xo, SchemaTableRegistry as Xr, ResolvedColumnBehavior as Xs, asc as Xt, ExplainFormat as Y, max as Ya, executeRows as Yc, IndexTerm as Yi, GroupingMeta as Yl, SelectCardinality as Yn, ColumnStorageDeclarationOf as Yo, SchemaTableRecord as Yr, MysqlIdentityExtension as Ys, OrderTerm as Yt, JsonScalarKind as Z, sum as Za, qubu as Zc, PostgresIndexExtension as Zi, HasSubquery as Zl, CteSource as Zn, ColumnStorageDialectOf as Zo, SchemaValidationError as Zr, SchemaLiteralValue as Zs, desc as Zt, SnapshotExpressionContext as _, fetchNext as _a, materializeSchemaObjectRecord as _c, KeyConstraint as _i, ExpressionSqlType as _l, doNothing as _n, notLike as _o, FromScope as _r, binary as _s, AnySource as _t, RequiresSourceMeta as _u, SnapshotBigInt as a, and as aa, SchemaDialectExtension as ac, CheckConstraint as ai, QueryValidationErrorCode as al, InsertSource as an, notExists as ao, except as ar, NativeStorage as as, SchemaLiteralRenderer as at, OutputOf as au, SnapshotGeneratedColumn as b, distinct as ba, ExecutionOptions as bc, PostgresConstraintExtension as bi, SchemaExpressionBrand as bl, onConflict as bn, notIn as bo, Selection as br, columnResultValue as bs, ProvidedSourceIdentity as bt, SubqueryMeta as bu, SnapshotConstraint as c, Omit$1 as ca, SchemaMetadataValidationError as cc, ConstraintOptions as ci, ColumnReference as cl, insertInto as cn, eq as co, unionAll as cr, PortableStorage as cs, resolveCastTarget as ct, ProvidesSourceMeta as cu, SnapshotDefault as d, omit as da, assertSchemaDialectSupport as dc, FieldLikeOptions as di, AnySchemaExpression as dl, ConflictAction as dn, isDistinctFrom as do, innerJoin as dr, StorageDeclarationOf as ds, QueryConfig as dt, RenderFunction as du, SqliteIndexExtension as ea, externalDefault as ec, schema as ei, RenderOptions as el, order as en, TypedSqlTag as eo, cte as er, ColumnStorageType as es, PaginationPart as et, InheritedMetadataOf as eu, SnapshotDiagnostic as f, where as fa, dialectMismatchDiagnostic as fc, ForeignKeyConstraint as fi, Expression as fl, ConflictTarget as fn, isNotDistinctFrom as fo, leftJoin as fr, StorageDescriptor as fs, QueryKind as ft, RequiresCapabilityMeta as fu, SnapshotExpression as g, fetchFirst as ga, materializeSchemaObjectIdentity as gc, ForeignKeyTargetInput as gi, ExpressionRequires as gl, OnConflictClause as gn, ne as go, FromClause as gr, bigint as gs, Row as gt, RequiresOuterSourceMeta as gu, SnapshotDialectExtension as h, rowLock as ha, isValidSchemaObjectName as hc, ForeignKeyTarget as hi, ExpressionOutput as hl, ExcludedSource as hn, lte as ho, groupBy as hr, StorageTypeOf as hs, QueryWithRow as ht, RequiresOuterOf as hu, SchemaSnapshotInput as i, DeclaredColumnNullability as ia, resolveColumnBehavior as ic, CatalogCheckSql as ii, QueryValidationError as il, InsertSelectSource as in, inQuery as io, SetQuery as ir, NativeColumnStorage as is, RowLockWaitPolicy as it, NullableSourcesOf as iu, SnapshotStorageContext as j, jsonExists as ja, QubuClient as jc, catalogForeignKey as ji, ResultShape as jl, MutationRow as jn, mapResult as jo, SchemaExpressionInput as jr, uuid as js, SourceSqlTypes as jt, SqlDate as ju, SnapshotSpecialNumber as k, JsonPath as ka, ExplainResult as kc, UniqueNullSemantics as ki, ResultDecodingError as kl, MutationReturning as kn, typedValue as ko, SchemaExpressionError as kr, text as ks, SourceRow as kt, SqlBinary as ku, SnapshotCreateResult as l, OmittableSelectClause as la, SchemaObjectIdentity as lc, ConstraintTiming as li, expressionFragment as ll, insertSelect as ln, gt as lo, crossJoin as lr, PortableStorageDescriptor as ls, AnyQuery as lt, QueryCardinality as lu, SnapshotDialect as m, RowLockOptions as ma, generatedSchemaObjectName as mc, ForeignKeyOptions as mi, ExpressionNullability as ml, DoUpdateAction as mn, lt as mo, rightJoin as mr, StorageOf as ms, QuerySqlTypeMap as mt, RequiresOuterMetadataOf as mu, SchemaSnapshot as n, index as na, generatedColumn as nc, AnyKeyColumn as ni, render as nl, deleteFrom as nn, caseWhen as no, withCte as nr, ColumnUpdateInput as ns, PortableCastType as nt, NullabilityOf as nu, SnapshotCheckConstraint as o, not as oa, SchemaDialectName as oc, CheckConstraintOptions as oi, QueryValidationIssue as ol, ValuesSource as on, scalar as oo, intersect as or, NativeStorageDescriptor as os, assertDialectCapability as ot, ProvidesOuterOf as ou, SnapshotDiagnosticCode as p, RowLockClause as pa, freezeSchemaMetadata as pc, ForeignKeyMatch as pi, ExpressionKind as pl, DoNothingAction as pn, like as po, naturalJoin as pr, StorageDialectOf as ps, QueryRow as pt, RequiresOf as pu, DialectPagination as q, count as qa, TransactionalQueryAdapter as qc, IndexDialectExtension as qi, GroupingDependenciesOf as ql, RequiredScope as qn, ColumnSqlType as qo, SchemaTableEntry as qr, IdentityGeneration as qs, TableUpdateInput as qt, SchemaSnapshotAdapter as r, validateIndexDialect as ra, identityColumn as rc, CatalogCheckExpression as ri, QueryTypeValidation as rl, DefaultValuesSource as rn, exists as ro, SetOperator as rr, DialectNativeStorage as rs, RowLockMode as rt, NullableSourceMeta as ru, SnapshotColumn as s, or as sa, SchemaMetadataDiagnostic as sc, ConstraintDialectExtension as si, ColumnDependency as sl, defaultValues as sn, ComparisonValidation as so, union as sr, PortableColumnStorage as ss, createDialect as st, ProvidesOuterSourceMeta as su, AnySchema as t, TableIndex as ta, externalGeneratedColumn as tc, schemaNamingPolicyVersion as ti, RenderedQuery as tl, orderBy as tn, sql as to, recursiveCte as tr, ColumnStorageTypeOf as ts, PortableCastTarget as tt, MetadataOf as tu, SnapshotDecodeResult as u, SelectPart as ua, SchemaObjectNameOptions as uc, FieldLike as ui, AnyExpression as ul, values as un, gte as uo, fullJoin as ur, PortableStorageType as us, Query as ut, RenderContext as uu, SnapshotExtensionContext as v, offset as va, AdapterExecutionResult as vc, KeyConstraintOptions as vi, ExpressionWithOutput as vl, doUpdate as vn, between as vo, FromSource as vr, boolean as vs, CustomSource as vt, ResultMeta as vu, SnapshotIndexTermExpression as w, add as wa, ExplainOptions as wc, SourceLike as wi, withDialectCapability as wl, AllowAllClause as wn, Operand as wo, all as wr, nativeColumn as ws, SourceConfig as wt, isFragment as wu, SnapshotIdentity as x, AnySelectClause as xa, ExecutionRequest as xc, ReferentialAction as xi, isExpression as xl, UpdateAssignmentValue as xn, isNotNull as xo, SelectionObject as xr, date as xs, ProvidedSourceRow as xt, VisibleDependenciesOf as xu, SnapshotForeignKey as y, having as ya, DriverValueEncoder as yc, MysqlConstraintExtension as yi, SchemaExpression as yl, excluded as yn, inList as yo, from as yr, column as ys, CustomSourceOptions as yt, SqlTypeOf as yu, schemaSnapshotVersion as z, coalesce as za, QubuTransaction as zc, AliasIdentity as zi, CapabilitiesOf as zl, correlate as zn, ColumnHasDefault as zo, renderSchemaExpression as zr, ExpressionGeneratedColumnDescriptor as zs, TableColumns as zt, SqlOrderable as zu };