qubu 0.6.1 → 0.6.2

package/dist/{types-DUe6eeI0.d.mts → types-Dqr4o2I1.d.mts}

@@ -50,6 +50,8 @@ type SqlBigInt = SqlSemanticType<"bigint"> & SqlNumericLike & SqlOrderable<"nume
 type SqlBinary = SqlSemanticType<"binary"> & SqlEqualityComparable<"binary">;
 /** Any declared SQL semantic type, including user and dialect extensions. */
 type AnySqlType = SqlSemanticType<string>;
+/** Runtime name for a SQL semantic domain, including user and dialect extensions. */
+type SqlTypeName = AnySqlType["sqlType"];
 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;
@@ -123,7 +125,7 @@ type CardinalityMeta<TCardinality extends QueryCardinality = QueryCardinality> =
   readonly cardinality: TCardinality;
 };
 /** A fragment whose syntax must be rendered by a dialect with this capability. */
-type RequiresCapabilityMeta<TCapability extends DialectCapability = DialectCapability> = {
+type RequiresCapabilityMeta<TCapability extends string = DialectCapability> = {
   readonly kind: "requires-capability";
   readonly capability: TCapability;
 };
@@ -133,7 +135,8 @@ interface RenderContext {
   /** Whether selected fields name an application result or a SQL relation. */
   readonly projectionMode: "result" | "relation";
   append(text: string): void;
-  parameter(value: unknown): void;
+  /** Add one ordered parameter, optionally declaring its runtime SQL domain. */
+  parameter(value: unknown, sqlType?: SqlTypeName): void;
   render(part: Fragment<any>): void;
   /** Render an embedded query with SQL-facing projection names. */
   renderRelation(part: Fragment<any>): void;
@@ -208,7 +211,7 @@ type Cardinality<TMetadata> = TMetadata extends {
 } ? TCardinality : never;
 type RequiredCapabilities<TMetadata> = TMetadata extends {
   readonly kind: "requires-capability";
-  readonly capability: infer TCapability extends DialectCapability;
+  readonly capability: infer TCapability extends string;
 } ? TCapability : never;
 type InheritedMetadataOf<TMetadata> = WithoutResult<TMetadata>;
 type InheritedMetadata<T> = InheritedMetadataOf<MetadataOf<T>>;
@@ -248,7 +251,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" | "bigint";
 /** Context supplied while decoding one projected field. */
 interface ResultDecodeContext {
   readonly dialect: Dialect;
@@ -264,6 +267,8 @@ interface ResultField {
   readonly name: string;
   readonly type?: DecodableResultType;
   readonly decoder?: ResultDecoder;
+  /** SQL semantic domain supplied to the adapter before it executes the request. */
+  readonly sqlType?: SqlTypeName;
 }
 /** Runtime description of a query's named result row. */
 interface ResultShape {
@@ -272,11 +277,14 @@ interface ResultShape {
 interface ResultValueMetadata {
   readonly type?: DecodableResultType;
   readonly decoder?: ResultDecoder;
+  /** SQL semantic domain retained for adapter-specific result handling. */
+  readonly sqlType?: SqlTypeName;
 }
 declare const resultValueMetadata: unique symbol;
 type ResultValueCarrier = {
   readonly [resultValueMetadata]?: ResultValueMetadata;
 };
+declare function resultValue(type?: DecodableResultType, decoder?: ResultDecoder, sqlType?: SqlTypeName): ResultValueMetadata | undefined;
 /** Decode SQLite/MySQL-style boolean values while accepting native booleans. */
 declare const booleanResultDecoder: ResultDecoder<boolean>;
 /** Decode a SQL DATE string as a JavaScript Date at UTC midnight. */
@@ -285,6 +293,8 @@ declare const dateResultDecoder: ResultDecoder<Date>;
 declare const timestampResultDecoder: ResultDecoder<Date>;
 /** Decode a serialized JSON result. Use only when the adapter returns JSON text. */
 declare const jsonTextResultDecoder: ResultDecoder;
+/** Decode an exact integer result without ever accepting an unsafe JavaScript number. */
+declare const bigintResultDecoder: ResultDecoder<bigint>;
 /** Error raised when a projected driver value cannot be decoded. */
 declare class ResultDecodingError extends TypeError {
   readonly name = "ResultDecodingError";
@@ -319,7 +329,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 string, 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. */
@@ -401,15 +411,17 @@ type DefaultDialectCapability = "json";
 interface RenderedQuery {
   readonly text: string;
   readonly parameters: readonly unknown[];
+  /** Runtime SQL domains aligned with `parameters`; omitted when all domains are unknown. */
+  readonly parameterSqlTypes?: readonly (SqlTypeName | undefined)[];
 }
-interface RenderOptions<TCapabilities extends DialectCapability = DialectCapability> {
+interface RenderOptions<TCapabilities extends string = string> {
   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>>;
+type MissingCapabilities<TQuery, TCapabilities extends string> = IsAny$1<CapabilitiesOf<TQuery>> extends true ? never : Exclude<CapabilitiesOf<TQuery>, TCapabilities>;
+type RenderCapabilityValidation<TQuery, TCapabilities extends string> = [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;
+declare function render<TQuery extends AnyFragment, TCapabilities extends string>(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> & {
@@ -506,9 +518,9 @@ interface QubuHooks {
 interface QubuOptions {
   readonly hooks?: QubuHooks;
 }
-/** One rendered statement and the controls passed to an application adapter. */
+/** One rendered statement, runtime parameter domains, and controls passed to an application adapter. */
 interface ExecutionRequest {
-  /** SQL text and raw application parameters produced by Qubu's renderer. */
+  /** SQL text, raw application parameters, and optional domain sidecar produced by Qubu's renderer. */
   readonly statement: RenderedQuery;
   /** The source query kind, available without parsing rendered SQL. */
   readonly queryKind: QueryKind;
@@ -550,9 +562,10 @@ interface ExplainResult<TPlanRow extends object = Record<string, unknown>> {
 }
 /**
  * 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.
+ * placeholder order, and `request.statement.parameterSqlTypes` optionally contains their aligned
+ * SQL domains. 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. */
@@ -594,6 +607,8 @@ type QueryExecutor = QueryAdapter;
 interface TransactionalQueryAdapter<TTransactionAdapter extends QueryAdapter = QueryAdapter> extends QueryAdapter {
   transaction<T>(callback: (adapter: TTransactionAdapter) => Promise<T>, options?: TransactionOptions): Promise<T>;
 }
+/** Opt-in recursive transaction scopes; adapters own savepoints and scope lifetime. */
+interface NestedTransactionalQueryAdapter<TBase extends QueryAdapter = QueryAdapter> extends TransactionalQueryAdapter<TBase & NestedTransactionalQueryAdapter<TBase>> {}
 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>;
@@ -618,7 +633,8 @@ interface QubuStreamingClient<TAdapter extends StreamingQueryAdapter = Streaming
 }
 /** 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>;
+type QubuBaseClientFor<TAdapter extends QueryAdapter> = TAdapter extends StreamingQueryAdapter ? TAdapter extends ExplainableQueryAdapter ? QubuStreamingExplainableClient<TAdapter> : QubuStreamingClient<TAdapter> : TAdapter extends ExplainableQueryAdapter ? QubuExplainableClient<TAdapter> : QubuClient<TAdapter>;
+type QubuClientFor<TAdapter extends QueryAdapter> = QubuBaseClientFor<TAdapter> & (TAdapter extends TransactionalQueryAdapter ? QubuTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>> : {});
 /** The client available inside a transaction callback. */
 type QubuTransaction = QubuClient<QueryAdapter>;
 /** The streaming client available inside a streaming transaction callback. */
@@ -638,6 +654,7 @@ interface QubuStreamingTransactionalClient<TAdapter extends StreamingTransaction
   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 NestedTransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuClientFor<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableStreamingTransactionalClient<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
 declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
@@ -649,8 +666,11 @@ declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdap
 declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuStreamingClient<TAdapter>;
 declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuClient<TAdapter>;
 interface DriverValueEncoder<TDriverValue = unknown> {
-  /** Convert one Qubu parameter into the driver's bindable representation. */
-  encode(value: unknown): TDriverValue;
+  /**
+   * Convert one Qubu parameter into the driver's bindable representation and receive its SQL
+   * domain.
+   */
+  encode(value: unknown, sqlType?: SqlTypeName): TDriverValue;
 }
 /**
  * Render a typed query, pass it to an application adapter, and return the adapter's structured
@@ -798,6 +818,10 @@ type GeneratedColumnDescriptor = ExpressionGeneratedColumnDescriptor | ExternalG
 type GeneratedDescriptor = GeneratedColumnDescriptor;
 /** Identity generation policy. Identity is not an ordinary SQL expression. */
 type IdentityGeneration = "always" | "by-default";
+/** Literal or deterministic schema-expression identity option value. */
+type IdentityOptionValue = SchemaLiteralValue | AnySchemaExpression;
+/** Dialect-neutral identity options retained in Snapshot v1. */
+type IdentityOptions = Readonly<Record<string, IdentityOptionValue>>;
 /** SQLite's opt-in AUTOINCREMENT behavior for an INTEGER rowid alias. */
 interface SqliteIdentityExtension extends SchemaDialectExtension<"sqlite"> {
   /** Preserve deleted rowids instead of allowing SQLite to reuse them. */
@@ -814,6 +838,7 @@ type IdentityDialectExtension = SqliteIdentityExtension | MysqlIdentityExtension
 interface IdentityDescriptor {
   readonly kind: "identity";
   readonly generation: IdentityGeneration;
+  readonly options?: IdentityOptions;
   /** Optional dialect-owned identity semantics such as SQLite AUTOINCREMENT. */
   readonly dialect?: IdentityDialectExtension;
 }
@@ -838,6 +863,7 @@ declare function externalGeneratedColumn(): ExternalGeneratedColumnDescriptor;
 /** Describe a database identity column without inventing a generated SQL expression. */
 declare function identityColumn(generation?: IdentityGeneration, options?: {
   readonly dialect?: IdentityDialectExtension;
+  readonly options?: IdentityOptions;
 }): IdentityDescriptor;
 /** The normalized behavior fields attached to a column definition. */
 interface ResolvedColumnBehavior {
@@ -951,8 +977,12 @@ interface ColumnOptions<TOutput = unknown, TInsert = TOutput> {
   readonly onUpdate?: AnySchemaExpression;
   /** Override the snake_case SQL identifier derived from the field name. */
   readonly sqlName?: string;
+  /** Runtime SQL semantic domain name for adapter binding and result metadata. */
+  readonly sqlType?: SqlTypeName;
   /** Physical storage metadata for a custom column definition. */
   readonly storage?: ColumnStorage;
+  /** Dialect-owned column metadata retained by schema snapshots. */
+  readonly dialect?: SchemaDialectExtension;
   /** Override adapter decoding for values selected from this column. */
   readonly decode?: ResultDecoder;
   /** Convert values at the live application-to-driver boundary without affecting schema metadata. */
@@ -963,8 +993,9 @@ interface ColumnOptions<TOutput = unknown, TInsert = TOutput> {
    */
   readonly castType?: string;
 }
-type BuiltInColumnOptions<TOutput> = Omit<ColumnOptions<TOutput, TOutput>, "castType" | "storage"> & {
+type BuiltInColumnOptions<TOutput> = Omit<ColumnOptions<TOutput, TOutput>, "castType" | "sqlType" | "storage"> & {
   readonly castType?: never;
+  readonly sqlType?: never;
   readonly storage?: never;
 };
 /** Sparse type-level configuration carried by a column definition. */
@@ -1033,8 +1064,12 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   /** MySQL's optional parameter-free `ON UPDATE` expression. */
   readonly onUpdate?: ColumnConfigOnUpdate<TConfig>;
   readonly sqlName?: string;
+  /** Runtime SQL semantic domain name for adapter binding and result metadata. */
+  readonly sqlType?: SqlTypeName;
   /** Physical storage metadata, separate from the application and SQL types. */
   readonly storage?: ColumnConfigStorage<TConfig>;
+  /** Dialect-owned metadata retained by schema snapshots. */
+  readonly dialect?: SchemaDialectExtension;
   /** Runtime decoder used when this definition is projected. */
   readonly resultDecoder?: ResultDecoder;
   /** Runtime default used when an application insert omits this definition. */
@@ -1266,9 +1301,13 @@ declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert,
 declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends ColumnOptions<TOutput, TInsert> = {}, TSqlType extends AnySqlType = SqlUnknown>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
 /** Resolve the runtime result metadata carried by a column definition. */
 declare function columnResultValue(definition: {
-  readonly storage?: ColumnStorage;
+  readonly sqlType?: SqlTypeName;
   readonly resultDecoder?: ResultDecoder;
 }): ResultValueMetadata | undefined;
+/** Resolve a column's explicit runtime semantic SQL domain for driver-facing metadata. */
+declare function columnSqlType(definition: {
+  readonly sqlType?: SqlTypeName;
+}): SqlTypeName | undefined;
 /** Apply a live column codec while preserving SQL NULL unchanged. */
 declare function encodeColumnParameter(definition: {
   readonly parameterEncoder?: (value: any) => unknown;
@@ -1352,10 +1391,16 @@ declare function mapResult<TOutput, TExpression extends AnyExpression>(expressio
 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>;
-/** Bind a value while declaring its SQL semantic domain. */
-declare function typedValue<TSqlType extends AnySqlType, T>(input: T): ValueExpression<T, TSqlType>;
-declare function asValue<TInput>(input: TInput): TInput extends AnyExpression ? TInput : ValueExpression<TInput>;
+/** Build a parameterized value expression with an optional runtime SQL domain for the adapter. */
+declare function value<T>(input: T, sqlType?: SqlTypeName): ValueExpression<T>;
+/**
+ * Bind a value while declaring its compile-time and runtime SQL semantic domain.
+ *
+ * @remarks
+ *   The domain is a binding hint; it does not select a JavaScript result decoder.
+ */
+declare function typedValue<TSqlType extends AnySqlType, T>(input: T, sqlType: TSqlType["sqlType"]): ValueExpression<T, TSqlType>;
+declare function asValue<TInput>(input: TInput, sqlType?: SqlTypeName): TInput extends AnyExpression ? TInput : ValueExpression<TInput>;
 //#endregion
 //#region src/expressions/operators/shared.d.ts
 type Operand<T> = T | ExpressionWithOutput<T>;
@@ -1690,7 +1735,7 @@ declare function typedCall<TSqlType extends AnySqlType, TOutput = unknown>(): <c
 type TextOperandValidation<TInput> = SqlCapabilityValidation<OperandSqlType<TInput, SqlText>, SqlTextLike>;
 type TextArgumentsValidation<TArguments extends readonly unknown[]> = TArguments extends readonly [infer THead, ...infer TTail] ? SqlCapabilityValidation<OperandSqlType<THead, SqlText>, SqlTextLike> & TextArgumentsValidation<TTail> : unknown;
 type CoalesceValidation<TFirst, TRest extends readonly unknown[]> = TRest extends readonly [infer THead, ...infer TTail] ? SqlEqualityValidation<ExpressionSqlType<TFirst>, OperandSqlType<THead, ExpressionSqlType<TFirst>>> & CoalesceValidation<TFirst, TTail> : unknown;
-declare function lower<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): SchemaExpression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? T extends {
+declare function lower<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): Expression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TInput> extends (infer T_2) ? T_2 extends MetadataOf<TInput> ? T_2 extends {
   readonly kind: "result";
@@ -1701,8 +1746,8 @@ declare function lower<const TInput extends Operand<string>>(input: TInput & Tex
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never : never : never> | (MetadataOf<TInput> extends (infer T_4) ? T_4 extends MetadataOf<TInput> ? T_4 extends {
   readonly kind: "result" | "cardinality";
-} ? never : T_4 : never : never), "function">;
-declare function upper<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): SchemaExpression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? T extends {
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function upper<const TInput extends Operand<string>>(input: TInput & TextOperandValidation<TInput>): Expression<ResultMeta<string, (MetadataOf<TInput> extends (infer T) ? T extends MetadataOf<TInput> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TInput> extends (infer T_2) ? T_2 extends MetadataOf<TInput> ? T_2 extends {
   readonly kind: "result";
@@ -1713,14 +1758,14 @@ declare function upper<const TInput extends Operand<string>>(input: TInput & Tex
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never : never : never> | (MetadataOf<TInput> extends (infer T_4) ? T_4 extends MetadataOf<TInput> ? T_4 extends {
   readonly kind: "result" | "cardinality";
-} ? never : T_4 : never : never), "function">;
-declare function coalesce<T, TFirst extends ExpressionWithOutput<T>, const TRest extends readonly Operand<NoInfer<T>>[]>(first: TFirst, ...rest: TRest & CoalesceValidation<TFirst, TRest>): SchemaExpression<ResultMeta<T, never, ExpressionSqlType<TFirst>> | ExpressionMeta<MetadataOf<[TFirst, ...TRest][number]> extends (infer T_1) ? T_1 extends MetadataOf<[TFirst, ...TRest][number]> ? T_1 extends {
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function coalesce<T, TFirst extends ExpressionWithOutput<T>, const TRest extends readonly Operand<NoInfer<T>>[]>(first: TFirst, ...rest: TRest & CoalesceValidation<TFirst, TRest>): Expression<ResultMeta<T, never, ExpressionSqlType<TFirst>> | ExpressionMeta<MetadataOf<[TFirst, ...TRest][number]> extends (infer T_1) ? T_1 extends MetadataOf<[TFirst, ...TRest][number]> ? T_1 extends {
   readonly kind: "expression";
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never : never : never> | (MetadataOf<[TFirst, ...TRest][number]> extends (infer T_2) ? T_2 extends MetadataOf<[TFirst, ...TRest][number]> ? T_2 extends {
   readonly kind: "result" | "cardinality";
-} ? never : T_2 : never : never), "function">;
-declare function concat<const TArguments extends readonly Operand<string>[]>(...argumentsToConcat: TArguments & TextArgumentsValidation<TArguments>): SchemaExpression<ResultMeta<string, (MetadataOf<TArguments[number]> extends (infer T) ? T extends MetadataOf<TArguments[number]> ? T extends {
+} ? never : T_2 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
+declare function concat<const TArguments extends readonly Operand<string>[]>(...argumentsToConcat: TArguments & TextArgumentsValidation<TArguments>): Expression<ResultMeta<string, (MetadataOf<TArguments[number]> extends (infer T) ? T extends MetadataOf<TArguments[number]> ? T extends {
   readonly kind: "result";
 } ? T : never : never : never) extends (infer T_1) ? T_1 extends (MetadataOf<TArguments[number]> extends (infer T_2) ? T_2 extends MetadataOf<TArguments[number]> ? T_2 extends {
   readonly kind: "result";
@@ -1731,7 +1776,7 @@ declare function concat<const TArguments extends readonly Operand<string>[]>(...
   readonly dependencies: infer TDependencies;
 } ? TDependencies : never : never : never> | (MetadataOf<TArguments[number]> extends (infer T_4) ? T_4 extends MetadataOf<TArguments[number]> ? T_4 extends {
   readonly kind: "result" | "cardinality";
-} ? never : T_4 : never : never), "function">;
+} ? never : T_4 : never : never), "function"> & SchemaExpressionBrand & ResultValueCarrier;
 //#endregion
 //#region src/expressions/functions/window.d.ts
 type WindowOrder = AnyExpression | OrderTerm<any>;
@@ -2671,6 +2716,11 @@ type DeclaredColumnNullabilityOf<TColumn> = TColumn extends DeclaredColumnNullab
 //#endregion
 //#region src/schema/indexes.d.ts
 type IndexTerm = AnyExpression | OrderTerm<any>;
+/** Additional physical facts attached to one index term. */
+interface IndexTermOptions {
+  readonly prefixLength?: SchemaLiteralValue | AnySchemaExpression;
+  readonly operatorClass?: string;
+}
 /** PostgreSQL-specific index method and storage metadata. */
 interface PostgresIndexExtension extends SchemaDialectExtension<"postgresql"> {
   readonly method?: "btree" | "hash" | "gist" | "spgist" | "gin" | "brin";
@@ -2699,6 +2749,12 @@ interface IndexOptions<TPredicate extends AnyExpression | undefined = AnyExpress
   readonly include?: readonly ColumnReference<string, any>[];
   /** Typed engine-specific index options. */
   readonly dialect?: TExtension;
+  /** Exact engine index method, when it is not dialect-extension data. */
+  readonly method?: string;
+  /** Physical backing constraint name, when the engine exposes one. */
+  readonly backingConstraint?: string;
+  /** Prefix lengths and operator classes aligned with the terms array. */
+  readonly termOptions?: readonly (IndexTermOptions | undefined)[];
 }
 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;
@@ -2711,7 +2767,8 @@ 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;
+type HasTermOptions<TOptions> = "termOptions" extends keyof TOptions ? true : false;
+type IsCandidateKey<TTerms extends readonly IndexTerm[], TOptions extends IndexOptions<any>> = HasTermOptions<TOptions> extends true ? false : UniqueOption<TOptions> extends false ? false : PredicatePresence<TOptions> extends true ? false : AllEligibleColumns<TTerms> extends false ? false : UniqueOption<TOptions> extends true ? PredicatePresence<TOptions> extends false ? AllEligibleColumns<TTerms> extends true ? true : boolean : boolean : boolean;
 /** 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";
@@ -2722,6 +2779,9 @@ interface TableIndex<TTerms extends readonly IndexTerm[] = any, TOptions extends
     readonly include: infer TIncluded;
   } ? TIncluded : undefined;
   readonly dialect?: DialectOption<TOptions>;
+  readonly method?: "method" extends keyof TOptions ? TOptions["method"] : undefined;
+  readonly backingConstraint?: "backingConstraint" extends keyof TOptions ? TOptions["backingConstraint"] : undefined;
+  readonly termOptions?: "termOptions" extends keyof TOptions ? TOptions["termOptions"] : undefined;
   readonly candidateKey: IsCandidateKey<TTerms, TOptions>;
 }
 /** The widened index shape accepted by source metadata records. */
@@ -2732,6 +2792,9 @@ interface SourceIndex {
   readonly predicate: AnyExpression | undefined;
   readonly includedColumns?: readonly ColumnReference<string, any>[];
   readonly dialect?: IndexDialectExtension;
+  readonly method?: string;
+  readonly backingConstraint?: string;
+  readonly termOptions?: readonly (IndexTermOptions | undefined)[];
   readonly candidateKey: boolean;
 }
 type SourceIndexesRecord = Readonly<Record<string, SourceIndex>>;
@@ -2879,11 +2942,15 @@ interface MysqlConstraintExtension extends SchemaDialectExtension<"mysql"> {
 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 {
+  /** Whether the database constraint has been validated. */
+  readonly validated?: boolean;
   /** 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> {
+  /** Physical backing index name, when exposed by the database. */
+  readonly backingIndex?: string;
   /** Whether the key can be deferred by a supporting dialect. */
   readonly deferrable?: boolean;
   /** Initial enforcement timing for a deferrable key. */
@@ -2891,6 +2958,8 @@ interface KeyConstraintOptions<TExtension extends ConstraintDialectExtension | u
 }
 /** Options for a database unique constraint, including nullable columns. */
 interface UniqueConstraintOptions<TExtension extends ConstraintDialectExtension | undefined = ConstraintDialectExtension | undefined> extends ConstraintOptions<TExtension> {
+  /** Physical backing index name, when exposed by the database. */
+  readonly backingIndex?: string;
   /**
    * SQL NULL comparison semantics. `distinct` is the common default in which multiple NULL values
    * do not conflict; `not-distinct` permits at most one.
@@ -2931,6 +3000,8 @@ interface KeyConstraint<TKind extends "primary-key" | "unique" = "primary-key" |
   readonly columns: TColumns;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
+  readonly backingIndex?: string;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -2947,6 +3018,7 @@ interface ForeignKeyConstraint<TColumns extends readonly AnyKeyColumn[] = readon
   readonly target: TTarget;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
   readonly onUpdate?: ReferentialAction;
   readonly onDelete?: ReferentialAction;
   readonly match?: ForeignKeyMatch;
@@ -2960,6 +3032,8 @@ interface UniqueConstraint<TColumns extends readonly AnyKeyColumn[] = readonly A
   readonly nulls: TNulls;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
+  readonly backingIndex?: string;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -2969,6 +3043,7 @@ interface CheckConstraint<TExpression extends AnyExpression = AnyExpression> ext
   readonly expression: TExpression;
   readonly physicalName?: string;
   readonly dialect?: ConstraintDialectExtension;
+  readonly validated?: boolean;
   readonly deferrable?: boolean;
   readonly initially?: ConstraintTiming;
 }
@@ -3238,14 +3313,14 @@ interface SchemaDialectHooks {
  * 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> {
+interface SchemaDialect<TCapabilities extends string = 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.
  */
-declare function createSchemaDialect<const TCapabilities extends DialectCapability = DialectCapability>(queryDialect: Dialect<TCapabilities>, schema: SchemaDialectHooks): SchemaDialect<TCapabilities>;
+declare function createSchemaDialect<const TCapabilities extends string = DialectCapability>(queryDialect: Dialect<TCapabilities>, schema: SchemaDialectHooks): SchemaDialect<TCapabilities>;
 //#endregion
 //#region src/query/selection.d.ts
 /**
@@ -3544,6 +3619,33 @@ declare function update<const TTable extends AnyTable, const TAssignments extend
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
+//#region src/query/mutation/on-duplicate-key-update.d.ts
+/** Identity of the proposed row for one MySQL INSERT target. */
+type IncomingIdentity<TIdentity> = {
+  readonly sourceKind: "mysql-incoming";
+  readonly table: TIdentity;
+};
+/** Typed proposed-row columns usable only in duplicate-key assignments. */
+type IncomingColumns<TTable extends AnyTable> = SourceColumns<SourceRow<TTable>, IncomingIdentity<SourceIdentity<TTable>>, SourceSqlTypeMap<TTable>>;
+/**
+ * Reference the incoming row in MySQL duplicate-key assignments. INSERT SELECT exposes only its
+ * explicit target columns; other references fail during rendering. These references cannot be used
+ * as a FROM source.
+ */
+declare function incoming<const TTable extends AnyTable>(table: TTable): IncomingColumns<TTable>;
+type AssignmentValidation<TTable extends AnyTable, TAssignments extends object> = TAssignments extends UpdateAssignments<TTable> ? Exclude<keyof TAssignments, keyof UpdateAssignments<TTable>> extends never ? Exclude<RequiresOf<TAssignments[keyof TAssignments]> | RequiresOuterOf<TAssignments[keyof TAssignments]>, SourceIdentity<TTable> | IncomingIdentity<SourceIdentity<TTable>>> extends never ? unknown : QueryTypeValidation<"missing-source", "upsert.duplicate-key.assignments", "Use only the target table and its incoming row."> : QueryTypeValidation<"invalid-update", "upsert.duplicate-key.assignments", "Use only writable target columns."> : QueryTypeValidation<"invalid-update", "upsert.duplicate-key.assignments", "Provide target-compatible assignment values.">;
+/** MySQL INSERT clause; conflicts are determined by the database's keys. */
+interface OnDuplicateKeyUpdateClause<TTable extends AnyTable = AnyTable, TAssignments extends object = object> extends Fragment<RequiresCapabilityMeta<"on-duplicate-key-update"> | RequiresSourceMeta<SourceIdentity<TTable>> | CapabilityMetadataOf<TAssignments[keyof TAssignments]>> {
+  readonly clauseKind: "on-duplicate-key-update";
+  readonly table: TTable;
+}
+/**
+ * Update writable columns when a MySQL INSERT row conflicts with a key. Raw values use target
+ * column encoders. Expressions may reference the target table or incoming(table). At least one
+ * non-omitted assignment is required.
+ */
+declare function onDuplicateKeyUpdate<const TTable extends AnyTable, const TAssignments extends object>(table: TTable, assignments: TAssignments & AssignmentValidation<TTable, TAssignments>): OnDuplicateKeyUpdateClause<TTable, TAssignments>;
+//#endregion
 //#region src/query/mutation/on-conflict.d.ts
 type ExcludedIdentity<TTableIdentity> = {
   readonly sourceKind: "excluded";
@@ -3592,7 +3694,7 @@ interface OnConflictClause<TAction extends ConflictAction = ConflictAction> exte
   readonly target: KeyConstraint | SourceIndex | undefined;
   readonly action: TAction;
 }
-type InsertClause = MutationReturningClause | OnConflictClause | MutationWithClause;
+type InsertClause = MutationReturningClause | OnConflictClause | MutationWithClause | OnDuplicateKeyUpdateClause<any, any>;
 declare function onConflict(action: DoNothingAction): OnConflictClause<DoNothingAction>;
 declare function onConflict<const TTable extends AnyTable, const TTarget extends ConflictTarget<TTable>, const TAction extends ConflictAction>(table: TTable, target: TTarget, action: TAction & ConflictActionValidation<TTable, TAction>): OnConflictClause<TAction>;
 //#endregion
@@ -3630,7 +3732,11 @@ type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> =
 } | {
   hasRuntimeDefault: 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;
-declare function insertInto<const TTable extends AnyTable, const TSource extends InsertSource, const TClauses extends readonly InsertClause[]>(table: TTable, source: TSource & ValidInsertSource<TTable, TSource> & InsertValuesScopeValidation<TSource>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses>): MutationQuery<{
+declare function insertInto<const TTable extends AnyTable, const TSource extends InsertSource, const TClauses extends readonly InsertClause[]>(table: TTable, source: TSource & ValidInsertSource<TTable, TSource> & InsertValuesScopeValidation<TSource>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses> & (Extract<TClauses[number], {
+  clauseKind: "on-duplicate-key-update";
+}> extends never ? unknown : Extract<TClauses[number], {
+  clauseKind: "returning";
+}> extends never ? unknown : QueryTypeValidation<"invalid-mutation", "insert.duplicate-key", "MySQL duplicate-key updates do not support RETURNING.">)): MutationQuery<{
   readonly row: MutationRow<TClauses>;
   readonly kind: "insert";
   readonly metadata: MutationMetadata<TClauses[number]> | InsertSourceMetadata<TSource>;
@@ -3645,6 +3751,37 @@ declare function deleteFrom<const TTable extends AnyTable, const TClauses extend
   readonly sqlTypes: MutationSqlTypes<TClauses>;
 }>;
 //#endregion
+//#region src/expressions/nested-json.d.ts
+type JsonSourceQuery = AnyQuery & {
+  readonly queryKind: "select" | "set";
+};
+type JsonQueryExpression<TQuery, TOutput> = Expression<ResultMeta<TOutput, never, SqlJson<TOutput>> | InheritedMetadata<TQuery> | SubqueryMeta, "subquery">;
+type ObjectQueryValidation<TQuery> = 0 extends 1 & CardinalityOf<TQuery> ? QueryTypeValidation<"invalid-subquery", "jsonObjectFrom.query", "Prove at most one row with fetchFirst(1)."> : [CardinalityOf<TQuery>] extends ["exactly-one" | "zero-or-one"] ? unknown : QueryTypeValidation<"invalid-subquery", "jsonObjectFrom.query", "Prove at most one row with fetchFirst(1).">;
+/**
+ * Turn a SELECT or set query into an inferred array expression; empty queries return [].
+ *
+ * Preserves correlation, explicit ordering and pagination on PostgreSQL, MySQL 8.0.21+, and SQLite
+ * 3.45+. Without ORDER BY, element order is unspecified. DISTINCT ordering must use expressions
+ * present in the projection.
+ *
+ * Nested fields require supported runtime SQL domains. Bigints, binary values and serialized JSON
+ * use exact text transport; dates and booleans are normalized without adapter-specific decoders.
+ * Unsupported domains or lossy numeric representations throw. Custom result decoders receive the
+ * transport value (including strings for bigint, decimal, binary hex and JSON), consistent with
+ * their unknown-input contract.
+ */
+declare function jsonArrayFrom<TQuery extends JsonSourceQuery>(query: TQuery): JsonQueryExpression<TQuery, QueryRow<TQuery>[]>;
+/**
+ * Turn a query proven to return at most one row into an inferred object.
+ *
+ * Empty queries return null; exactly-one queries retain a non-null result type. Use an
+ * unconditional fetchFirst(1) to prove the row bound for a table query. Shares dialect, projection
+ * and exact-decoding rules with {@link jsonArrayFrom}.
+ *
+ * @throws {TypeError} When the query lacks a runtime at-most-one-row proof.
+ */
+declare function jsonObjectFrom<TQuery extends JsonSourceQuery>(query: TQuery & ObjectQueryValidation<TQuery>): JsonQueryExpression<TQuery, QueryRow<TQuery> | ([CardinalityOf<TQuery>] extends ["exactly-one"] ? never : null)>;
+//#endregion
 //#region src/query/clauses/order-by.d.ts
 type OrderDirection = "ASC" | "DESC";
 type NullsOrder = "FIRST" | "LAST";
@@ -3686,6 +3823,7 @@ type AnyTable = Source<any> & {
   readonly definitions: TableDefinitions;
   /** Application field keys mapped to physical SQL column names. */
   readonly sqlNames: Readonly<Record<string, string>>;
+  readonly dialect?: SchemaDialectExtension;
 };
 type TableRow<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions]: ColumnOutput<TDefinitions[K]>; };
 /** SQL semantic domains derived from a table's column definitions. */
@@ -3712,11 +3850,13 @@ type Table<TName extends string = string, TDefinitions extends TableDefinitions
   readonly columns: TableColumns<TDefinitions, TableIdentity<TName>>;
   readonly constraints: TConstraints;
   readonly indexes: TIndexes;
+  readonly dialect?: SchemaDialectExtension;
 } & TableColumns<TDefinitions, TableIdentity<TName>>;
 /** Schema metadata that applies to a table as a relation. */
 interface TableOptions<TConstraints extends SourceConstraintsRecord = SourceConstraintsRecord, TIndexes extends SourceIndexesRecord = SourceIndexesRecord> {
   readonly constraints: TConstraints;
   readonly indexes: TIndexes;
+  readonly dialect?: SchemaDialectExtension;
 }
 type ConstraintColumns<TConstraint> = TConstraint extends KeyConstraint<any, infer TColumns> | UniqueConstraint<infer TColumns> | ForeignKeyConstraint<infer TColumns, any> ? TColumns[number] : never;
 type InvalidConstraintDependencies<TName extends string, TConstraints extends SourceConstraintsRecord> = Exclude<DependenciesOf<ConstraintColumns<TConstraints[keyof TConstraints]>>, ColumnDependency<TableIdentity<TName>, string>>;
@@ -3827,9 +3967,10 @@ interface CustomSourceOptions<TIdentity, TDefinitions extends TableDefinitions>
   readonly columns: TDefinitions;
   readonly sourceKind?: SourceKind;
 }
-type CustomSource<TIdentity, TDefinitions extends TableDefinitions> = Source<{
+type CustomSource<TIdentity, TDefinitions extends TableDefinitions, TMetadata = never> = Source<{
   readonly identity: TIdentity;
   readonly row: TableRow<TDefinitions>;
+  readonly metadata: TMetadata;
   readonly sqlTypes: TableSqlTypes<TDefinitions>;
 }> & {
   readonly identity: TIdentity;
@@ -3848,7 +3989,7 @@ declare function createSource<TIdentity, TRow extends object, TMetadata = never,
  * 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>;
+declare function customSource<const TIdentity, const TDefinitions extends TableDefinitions, const TMetadata = never>(options: CustomSourceOptions<TIdentity, TDefinitions>): CustomSource<TIdentity, TDefinitions, TMetadata>;
 /**
  * Add convenient direct column properties without allowing a column name to overwrite the source's
  * rendering or metadata primitives.
@@ -3874,9 +4015,13 @@ interface Query<TConfig extends QueryConfig = {}> extends Fragment<ResultMeta<re
   /** @internal Type-level configuration retained for inference. */
   readonly __queryConfig?: TConfig;
   readonly queryKind: QueryKind;
+  /** @internal Runtime row-bound proof retained by built-in query constructors. */
+  readonly cardinality?: QueryCardinality;
   readonly row: QueryConfigRow<TConfig>;
   /** Runtime metadata used to decode named result fields. */
   readonly resultShape: ResultShape;
+  /** @internal Render a SELECT with an ordering ordinal for nested JSON aggregation. */
+  readonly renderJsonRows?: (context: RenderContext, ordinal: string) => void;
   /** Type-only SQL domains of the named query projection. */
   readonly sqlTypes?: QueryConfigSqlTypes<TConfig>;
 }
@@ -3898,7 +4043,7 @@ 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" | "update-from";
+type DialectCapability = "ilike" | "json" | "on-conflict" | "on-duplicate-key-update" | "row-locking" | "update-from";
 /**
  * Optional dialect hook used by schema expressions when a JavaScript value must become SQL text
  * instead of a query parameter.
@@ -3961,7 +4106,7 @@ interface ExplainRenderOptions {
 interface DialectExplain {
   readonly render: (statement: string, queryKind: QueryKind, options: ExplainRenderOptions) => string;
 }
-interface Dialect<TCapabilities extends DialectCapability = DialectCapability> {
+interface Dialect<TCapabilities extends string = string> {
   readonly name: string;
   quoteIdentifier(identifier: string): string;
   placeholder(position: number): string;
@@ -3979,7 +4124,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 string = never, TJson extends DialectJson | undefined = DialectJson | undefined> {
   readonly name: string;
   readonly quoteIdentifier?: (identifier: string) => string;
   readonly placeholder: (position: number) => string;
@@ -4001,20 +4146,401 @@ 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.
  */
-declare function createDialect<const TCapabilities extends Exclude<DialectCapability, "json"> = never>(options: DialectOptions<TCapabilities, DialectJson> & {
+declare function createDialect<const TCapabilities extends string = 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>;
+declare function createDialect<const TCapabilities extends string = 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.
  */
-declare function assertDialectCapability(dialect: Dialect, capability: DialectCapability): void;
+declare function assertDialectCapability(dialect: Dialect<string>, capability: string): void;
+/** Extend a dialect with capabilities owned by an addon without changing its SQL policies. */
+declare function extendDialect<const TCapabilities extends string, const TAdditionalCapabilities extends string>(dialect: Dialect<TCapabilities>, additionalCapabilities: readonly TAdditionalCapabilities[]): Dialect<TCapabilities | TAdditionalCapabilities>;
+//#endregion
+//#region src/snapshot/complete-types.d.ts
+/** The canonical schema snapshot envelope tag. */
+declare const completeSchemaSnapshotFormat: "qubu-schema";
+/** The current strict format version for the complete catalog/object model. */
+declare const completeSchemaSnapshotVersion: 1;
+/** Descriptive alias for consumers that select a numbered snapshot version. */
+declare const schemaSnapshotV1Version: 1;
+/** Explicit format-version aliases for generated tooling and fixtures. */
+declare const schemaSnapshotCompleteVersion: 1;
+declare const schemaSnapshotVersion1: 1;
+/** Object families that may appear in a complete canonical snapshot. */
+type CompleteSnapshotObjectKind = "namespace" | "table" | "column" | "constraint" | "index" | "view" | "materialized-view" | "sequence" | "enum" | "domain" | "collation" | "trigger" | "routine" | "partition" | "policy" | "extension" | "comment" | "ownership" | "deferred-object" | "opaque-object";
+/** Object families that can own nested complete snapshot objects. */
+type CompleteSnapshotObjectOwnerKind = "table" | "view" | "materialized-view" | "domain";
+/** A non-recursive owner scope for a nested complete snapshot object. */
+interface CompleteSnapshotObjectOwner {
+  readonly kind: CompleteSnapshotObjectOwnerKind;
+  readonly id: string;
+}
+/** A stable logical object reference used by complete snapshot relations. */
+interface CompleteSnapshotObjectReference {
+  readonly kind: Exclude<CompleteSnapshotObjectKind, "namespace">;
+  readonly id: string;
+  /** Required when the target is a nested column, constraint, or index. */
+  readonly owner?: CompleteSnapshotObjectOwner;
+}
+/** Source evidence retained without persisting a database catalog key. */
+interface CompleteSnapshotProvenance {
+  readonly kind: "catalog" | "decompiler" | "create-sql";
+  readonly dialect: string;
+  readonly path?: readonly (string | number)[];
+}
+/** Physical-name evidence retained without ephemeral catalog identity keys. */
+interface CompleteSnapshotPhysicalReference {
+  readonly kind: CompleteSnapshotObjectKind;
+  readonly namespace?: string;
+  readonly table?: string;
+  readonly name: string;
+}
+/** Namespace identity and selected physical boundary for a snapshot. */
+interface CompleteSnapshotNamespace extends CompleteSnapshotObjectMetadata {
+  readonly kind: "generic" | "postgres-schema" | "sqlite-database" | "mysql-database";
+  readonly name: string;
+}
+/** Capability facts reported by the adapter that produced the snapshot. */
+interface CompleteSnapshotCapabilities {
+  readonly generatedColumns: boolean;
+  readonly identityMetadata: boolean;
+  readonly checkConstraints: boolean;
+  readonly checkConstraintEnforcement: "enforced" | "metadata-only" | "unknown";
+  readonly expressionDecompilation: boolean;
+  readonly indexExpressions: boolean;
+  readonly indexPredicates: boolean;
+  readonly indexIncludedColumns: boolean;
+  readonly namespaces: boolean;
+  readonly visibility: "complete" | "limited" | "unknown";
+  readonly [capability: string]: boolean | string;
+}
+/** Metadata common to every complete snapshot object. */
+interface CompleteSnapshotObjectMetadata {
+  readonly provenance?: CompleteSnapshotProvenance;
+  readonly physicalReference?: CompleteSnapshotPhysicalReference;
+  readonly dialect?: SnapshotDialectExtension;
+}
+/** A complete snapshot column, including physical ordinal evidence. */
+interface CompleteSnapshotColumn extends CompleteSnapshotObjectMetadata {
+  readonly kind: "column";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly ordinalPosition: number;
+  readonly nullable: boolean;
+  readonly hasDefault: boolean;
+  readonly generated: boolean;
+  readonly storage?: SnapshotStorage;
+  readonly default?: SnapshotDefault;
+  readonly generatedColumn?: SnapshotGeneratedColumn;
+  readonly identity?: CompleteSnapshotIdentity;
+  readonly onUpdate?: SnapshotExpression;
+}
+/** A richer identity declaration retained beside a column or sequence. */
+interface CompleteSnapshotIdentity extends CompleteSnapshotObjectMetadata {
+  readonly kind: "identity";
+  readonly generation: "always" | "by-default";
+  readonly options: Readonly<Record<string, CompleteSnapshotValueFact>>;
+}
+/** A literal or opaque expression value in complete object metadata. */
+type CompleteSnapshotValueFact = {
+  readonly kind: "literal";
+  readonly value: SnapshotLiteral;
+} | {
+  readonly kind: "expression";
+  readonly expression: SnapshotExpression;
+};
+/** An ordered column or expression term in a complete index. */
+type CompleteSnapshotIndexTerm = {
+  readonly kind: "column";
+  readonly column: string;
+  readonly position: number;
+  readonly direction?: "ASC" | "DESC";
+  readonly nulls?: "FIRST" | "LAST";
+  readonly prefixLength?: CompleteSnapshotValueFact;
+  readonly operatorClass?: string;
+} | {
+  readonly kind: "expression";
+  readonly expression: SnapshotExpression;
+  readonly position: number;
+  readonly direction?: "ASC" | "DESC";
+  readonly nulls?: "FIRST" | "LAST";
+  readonly operatorClass?: string;
+};
+/** A complete index with engine-specific method and included-column facts. */
+interface CompleteSnapshotIndex extends CompleteSnapshotObjectMetadata {
+  readonly kind: "index";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly terms: readonly CompleteSnapshotIndexTerm[];
+  readonly unique: boolean;
+  readonly candidateKey: boolean;
+  readonly predicate?: SnapshotExpression;
+  readonly includedColumns?: readonly string[];
+  readonly backingConstraint?: CompleteSnapshotObjectReference;
+  readonly method?: string;
+}
+/** A key or uniqueness constraint in a complete table. */
+interface CompleteSnapshotKeyConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: "primary-key" | "unique" | "unique-constraint";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly nulls?: "distinct" | "not-distinct";
+  readonly backingIndex?: CompleteSnapshotObjectReference;
+  readonly deferrable?: boolean;
+  readonly initially?: "immediate" | "deferred";
+  readonly validated?: boolean;
+}
+/** A foreign key with explicit target object identity and actions. */
+interface CompleteSnapshotForeignKey extends CompleteSnapshotObjectMetadata {
+  readonly kind: "foreign-key";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly string[];
+  readonly target: {
+    readonly table: CompleteSnapshotObjectReference;
+    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 deferrable?: boolean;
+  readonly initially?: "immediate" | "deferred";
+  readonly validated?: boolean;
+}
+/** A check constraint whose expression remains tagged data. */
+interface CompleteSnapshotCheckConstraint extends CompleteSnapshotObjectMetadata {
+  readonly kind: "check";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly expression: SnapshotExpression;
+  readonly deferrable?: boolean;
+  readonly initially?: "immediate" | "deferred";
+  readonly validated?: boolean;
+}
+/** Every constraint represented by the complete neutral snapshot model. */
+type CompleteSnapshotConstraint = CompleteSnapshotKeyConstraint | CompleteSnapshotForeignKey | CompleteSnapshotCheckConstraint;
+/** A complete table record keyed by stable logical identity. */
+interface CompleteSnapshotTable extends CompleteSnapshotObjectMetadata {
+  readonly kind: "table";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly constraints: readonly CompleteSnapshotConstraint[];
+  readonly indexes: readonly CompleteSnapshotIndex[];
+}
+/** A view or materialized-view declaration and its output columns. */
+interface CompleteSnapshotView extends CompleteSnapshotObjectMetadata {
+  readonly kind: "view" | "materialized-view";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly columns: readonly CompleteSnapshotColumn[];
+  readonly definition: SnapshotExpression;
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+  readonly checkOption?: "none" | "local" | "cascaded";
+  readonly securityBarrier?: boolean;
+  readonly securityInvoker?: boolean;
+}
+/** A sequence and its exact option facts. */
+interface CompleteSnapshotSequence extends CompleteSnapshotObjectMetadata {
+  readonly kind: "sequence";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage?: SnapshotStorage;
+  readonly start?: CompleteSnapshotValueFact;
+  readonly increment?: CompleteSnapshotValueFact;
+  readonly minimum?: CompleteSnapshotValueFact;
+  readonly maximum?: CompleteSnapshotValueFact;
+  readonly cache?: CompleteSnapshotValueFact;
+  readonly cycle?: boolean;
+  readonly ownedBy?: CompleteSnapshotObjectReference;
+  readonly identity?: CompleteSnapshotIdentity;
+}
+/** An ordered enum declaration. */
+interface CompleteSnapshotEnum extends CompleteSnapshotObjectMetadata {
+  readonly kind: "enum";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly values: readonly {
+    readonly value: string;
+    readonly ordinalPosition: number;
+    readonly provenance?: CompleteSnapshotProvenance;
+  }[];
+}
+/** A domain declaration and its base type constraints. */
+interface CompleteSnapshotDomain extends CompleteSnapshotObjectMetadata {
+  readonly kind: "domain";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly storage: SnapshotStorage;
+  readonly nullable?: boolean;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly constraints?: readonly CompleteSnapshotCheckConstraint[];
+}
+/** Collation behavior that can affect deterministic schema comparison. */
+interface CompleteSnapshotCollation extends CompleteSnapshotObjectMetadata {
+  readonly kind: "collation";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly provider?: string;
+  readonly locale?: string;
+  readonly deterministic?: boolean;
+  readonly version?: string;
+}
+/** Trigger declaration attached to a table or view. */
+interface CompleteSnapshotTrigger extends CompleteSnapshotObjectMetadata {
+  readonly kind: "trigger";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly timing: "before" | "after" | "instead-of" | "unknown";
+  readonly events: readonly ("insert" | "update" | "delete" | "truncate")[];
+  readonly orientation?: "row" | "statement";
+  readonly condition?: SnapshotExpression;
+  readonly body: SnapshotExpression;
+  readonly enabled?: boolean;
+}
+/** Routine argument declaration. */
+interface CompleteSnapshotRoutineParameter {
+  readonly name?: string;
+  readonly mode?: "in" | "out" | "inout" | "variadic" | "table";
+  readonly storage: SnapshotStorage;
+  readonly default?: CompleteSnapshotValueFact;
+  readonly ordinalPosition: number;
+  readonly provenance?: CompleteSnapshotProvenance;
+}
+/** Function, procedure, aggregate, or window routine declaration. */
+interface CompleteSnapshotRoutine extends CompleteSnapshotObjectMetadata {
+  readonly kind: "routine";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly routineKind: "function" | "procedure" | "aggregate" | "window" | "unknown";
+  readonly parameters: readonly CompleteSnapshotRoutineParameter[];
+  readonly returnType?: SnapshotStorage;
+  readonly language?: string;
+  readonly body?: SnapshotExpression;
+  readonly volatility?: "immutable" | "stable" | "volatile" | "unknown";
+  readonly parallel?: "safe" | "restricted" | "unsafe" | "unknown";
+  readonly security?: "invoker" | "definer" | "unknown";
+  readonly dependencies?: readonly CompleteSnapshotObjectReference[];
+}
+/** A partition child, its parent, and normalized bound expression. */
+interface CompleteSnapshotPartition extends CompleteSnapshotObjectMetadata {
+  readonly kind: "partition";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly parent: CompleteSnapshotObjectReference;
+  readonly strategy: "range" | "list" | "hash" | "reference" | "unknown";
+  readonly keyColumns?: readonly string[];
+  readonly bound?: SnapshotExpression;
+  readonly default?: boolean;
+}
+/** A row-level security policy attached to a table. */
+interface CompleteSnapshotPolicy extends CompleteSnapshotObjectMetadata {
+  readonly kind: "policy";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly table: CompleteSnapshotObjectReference;
+  readonly command: "all" | "select" | "insert" | "update" | "delete" | "unknown";
+  readonly roles?: readonly string[];
+  readonly permissive?: boolean;
+  readonly using?: SnapshotExpression;
+  readonly check?: SnapshotExpression;
+}
+/** An extension object with a typed, versioned payload. */
+interface CompleteSnapshotExtension extends CompleteSnapshotObjectMetadata {
+  readonly kind: "extension";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly extensionName: string;
+  readonly extensionVersion?: string;
+  readonly schema?: string;
+  readonly data: SnapshotJsonValue;
+  readonly configuration?: SnapshotJsonValue;
+}
+/** A deferred object retained as a reviewable, non-lossy boundary record. */
+interface CompleteSnapshotDeferredObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: "deferred-object";
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly reason?: string;
+  readonly data?: SnapshotJsonValue;
+}
+/** An opaque object observed by an adapter but not yet structurally modeled. */
+interface CompleteSnapshotOpaqueObject extends CompleteSnapshotObjectMetadata {
+  readonly kind: "opaque-object";
+  readonly id: string;
+  readonly objectKind: string;
+  readonly physicalName: string;
+  readonly data: SnapshotJsonValue;
+  readonly sql?: SnapshotExpression;
+}
+/** A comment attached to a stable logical object. */
+interface CompleteSnapshotComment extends CompleteSnapshotObjectMetadata {
+  readonly kind: "comment";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly text: string;
+}
+/** Ownership metadata attached to a stable logical object. */
+interface CompleteSnapshotOwnership extends CompleteSnapshotObjectMetadata {
+  readonly kind: "ownership";
+  readonly id: string;
+  readonly physicalName: string;
+  readonly object: CompleteSnapshotObjectReference;
+  readonly owner: string;
+}
+/** Every complete snapshot object family, including retained boundaries. */
+type CompleteSnapshotObject = CompleteSnapshotTable | CompleteSnapshotView | CompleteSnapshotSequence | CompleteSnapshotEnum | CompleteSnapshotDomain | CompleteSnapshotCollation | CompleteSnapshotTrigger | CompleteSnapshotRoutine | CompleteSnapshotPartition | CompleteSnapshotPolicy | CompleteSnapshotExtension | CompleteSnapshotDeferredObject | CompleteSnapshotOpaqueObject | CompleteSnapshotComment | CompleteSnapshotOwnership;
+/** The immutable strict Snapshot v1 envelope. */
+interface CompleteSchemaSnapshot {
+  readonly format: typeof completeSchemaSnapshotFormat;
+  readonly version: typeof completeSchemaSnapshotVersion;
+  readonly dialect: SnapshotDialect;
+  readonly namingPolicy: SnapshotNamingPolicy;
+  readonly namespace: CompleteSnapshotNamespace;
+  readonly capabilities: CompleteSnapshotCapabilities;
+  readonly tables: readonly CompleteSnapshotTable[];
+  readonly views: readonly CompleteSnapshotView[];
+  readonly sequences: readonly CompleteSnapshotSequence[];
+  readonly enums: readonly CompleteSnapshotEnum[];
+  readonly domains: readonly CompleteSnapshotDomain[];
+  readonly collations: readonly CompleteSnapshotCollation[];
+  readonly triggers: readonly CompleteSnapshotTrigger[];
+  readonly routines: readonly CompleteSnapshotRoutine[];
+  readonly partitions: readonly CompleteSnapshotPartition[];
+  readonly policies: readonly CompleteSnapshotPolicy[];
+  readonly extensions: readonly CompleteSnapshotExtension[];
+  readonly deferredObjects: readonly CompleteSnapshotDeferredObject[];
+  readonly opaqueObjects: readonly CompleteSnapshotOpaqueObject[];
+  readonly comments: readonly CompleteSnapshotComment[];
+  readonly ownership: readonly CompleteSnapshotOwnership[];
+}
+/** Input accepted by the strict complete snapshot encoder. */
+type CompleteSchemaSnapshotInput = CompleteSchemaSnapshot | Readonly<Record<string, unknown>>;
+/** A complete snapshot decoder result with immutable successful output. */
+type CompleteSnapshotDecodeResult = {
+  readonly ok: true;
+  readonly value: CompleteSchemaSnapshot;
+} | {
+  readonly ok: false;
+  readonly diagnostics: readonly SnapshotDiagnostic[];
+};
+/** A complete snapshot creation result with immutable successful output. */
+type CompleteSnapshotCreateResult = CompleteSnapshotDecodeResult;
+/** V1 aliases kept explicit for consumers that prefer numbered APIs. */
+type SchemaSnapshotV1 = CompleteSchemaSnapshot;
+type SchemaSnapshotV1Input = CompleteSchemaSnapshotInput;
+type SchemaSnapshotV1DecodeResult = CompleteSnapshotDecodeResult;
 //#endregion
 //#region src/snapshot/types.d.ts
 /** The JSON object tag used by Qubu schema snapshots. */
 declare const schemaSnapshotFormat: "qubu-schema";
-/** The first canonical schema snapshot format version. */
+/** The current canonical schema snapshot format version. */
 declare const schemaSnapshotVersion: 1;
 /** The first version of the dialect-extension envelope. */
 declare const schemaSnapshotDialectVersion: 1;
@@ -4104,27 +4630,11 @@ type SnapshotGeneratedColumn = {
 } | {
   readonly kind: "external";
 };
-/** Identity behavior is deliberately separate from generated expressions. */
-interface SnapshotIdentity {
-  readonly kind: "identity";
-  readonly generation: "always" | "by-default";
-  readonly dialect?: SnapshotDialectExtension;
-}
-/** A canonical column record keyed by its stable logical field ID. */
-interface SnapshotColumn {
-  readonly id: string;
-  readonly physicalName: string;
-  readonly nullable: boolean;
-  readonly hasDefault: boolean;
-  readonly generated: boolean;
-  readonly storage?: SnapshotStorage;
-  readonly default?: SnapshotDefault;
-  readonly generatedColumn?: SnapshotGeneratedColumn;
-  readonly identity?: SnapshotIdentity;
-  /** MySQL's parameter-free column update expression, when supported. */
-  readonly onUpdate?: SnapshotExpression;
-}
-/** An expression or bare column used by an index. */
+/** V1 object aliases kept in the short snapshot vocabulary used by consumers. */
+type SnapshotIdentity = CompleteSnapshotIdentity;
+type SnapshotColumn = CompleteSnapshotColumn;
+type SnapshotIndexTerm = CompleteSnapshotIndexTerm;
+/** The expression portion of an index term, without ordering metadata. */
 type SnapshotIndexTermExpression = {
   readonly kind: "column";
   readonly column: string;
@@ -4132,92 +4642,16 @@ type SnapshotIndexTermExpression = {
   readonly kind: "expression";
   readonly expression: SnapshotExpression;
 };
-/** One ordered index term. */
-type SnapshotIndexTerm = SnapshotIndexTermExpression | {
-  readonly kind: "order";
-  readonly expression: SnapshotIndexTermExpression;
-  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 physicalName: string;
-  readonly columns: readonly string[];
-  readonly deferrable?: boolean;
-  readonly initially?: "immediate" | "deferred";
-  readonly dialect?: SnapshotDialectExtension;
-}
-/** Nullable database uniqueness, intentionally not a candidate-key proof. */
-interface SnapshotUniqueConstraint {
-  readonly id: string;
+type SnapshotKeyConstraint = CompleteSnapshotKeyConstraint;
+type SnapshotUniqueConstraint = CompleteSnapshotKeyConstraint & {
   readonly kind: "unique-constraint";
-  readonly physicalName: string;
-  readonly columns: readonly string[];
-  readonly nulls: "distinct" | "not-distinct";
-  readonly deferrable?: boolean;
-  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 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 deferrable?: boolean;
-  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 physicalName: string;
-  readonly expression: SnapshotExpression;
-  readonly deferrable?: boolean;
-  readonly initially?: "immediate" | "deferred";
-  readonly dialect?: SnapshotDialectExtension;
-}
-/** Every constraint represented by the v1 neutral model. */
-type SnapshotConstraint = SnapshotKeyConstraint | SnapshotUniqueConstraint | SnapshotForeignKey | SnapshotCheckConstraint;
-/** A canonical index record keyed by its stable logical ID. */
-interface SnapshotIndex {
-  readonly id: string;
-  readonly kind: "index";
-  readonly physicalName: string;
-  readonly terms: readonly SnapshotIndexTerm[];
-  readonly unique: boolean;
-  readonly candidateKey: boolean;
-  readonly predicate?: SnapshotExpression;
-  readonly includedColumns?: readonly string[];
-  readonly dialect?: SnapshotDialectExtension;
-}
-/** A table record keyed by its stable logical registry ID. */
-interface SnapshotTable {
-  readonly id: string;
-  readonly physicalName: string;
-  readonly columns: readonly SnapshotColumn[];
-  readonly constraints: readonly SnapshotConstraint[];
-  readonly indexes: readonly SnapshotIndex[];
-}
-/** The immutable canonical schema snapshot envelope. */
-interface SchemaSnapshot {
-  readonly format: typeof schemaSnapshotFormat;
-  readonly version: typeof schemaSnapshotVersion;
-  readonly dialect: SnapshotDialect;
-  readonly namingPolicy: SnapshotNamingPolicy;
-  readonly namespace?: string;
-  readonly tables: readonly SnapshotTable[];
-}
+};
+type SnapshotForeignKey = CompleteSnapshotForeignKey;
+type SnapshotCheckConstraint = CompleteSnapshotCheckConstraint;
+type SnapshotConstraint = CompleteSnapshotConstraint;
+type SnapshotIndex = CompleteSnapshotIndex;
+type SnapshotTable = CompleteSnapshotTable;
+type SchemaSnapshot = CompleteSchemaSnapshot;
 /** Schema-expression context supplied to a dialect adapter. */
 interface SnapshotExpressionContext {
   readonly mode: "default" | "generated" | "check" | "index";
@@ -4244,7 +4678,7 @@ interface SnapshotValidationContext {
  * 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> {
+interface SchemaSnapshotAdapter<TCapabilities extends string = DialectCapability> {
   /** The query dialect plus its schema hooks and metadata. */
   readonly dialect: SchemaDialect<TCapabilities>;
 }
@@ -4258,24 +4692,12 @@ interface SnapshotDiagnostic {
   readonly relatedPaths?: readonly (readonly (string | number)[])[];
 }
 /** Result returned by the strict snapshot decoder. */
-type SnapshotDecodeResult = {
-  readonly ok: true;
-  readonly value: SchemaSnapshot;
-} | {
-  readonly ok: false;
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-};
+type SnapshotDecodeResult = CompleteSnapshotDecodeResult;
 /** Result returned by a non-throwing schema traversal helper. */
-type SnapshotCreateResult = {
-  readonly ok: true;
-  readonly value: SchemaSnapshot;
-} | {
-  readonly ok: false;
-  readonly diagnostics: readonly SnapshotDiagnostic[];
-};
+type SnapshotCreateResult = CompleteSnapshotCreateResult;
 /** A schema snapshot input accepted by the canonical encoder. */
-type SchemaSnapshotInput = SchemaSnapshot | Readonly<Record<string, unknown>>;
+type SchemaSnapshotInput = CompleteSchemaSnapshotInput;
 /** Expose the schema generic in tooling declarations without widening APIs. */
 type AnySchema = Schema<any>;
 //#endregion
-export { PaginationKind as $, countDistinct as $a, QubuExplainableTransactionalClient as $c, IndexOptions as $i, booleanResultDecoder as $l, ScopeValidation as $n, ColumnOutput as $o, SchemaTableNames as $r, IdentityDescriptor as $s, nullsLast as $t, SqlDecimal as $u, SnapshotStorage as A, divide as Aa, ExecutionResult as Ac, SqliteConstraintExtension as Ai, expressionFragment as Al, MutationClause as An, OperandNullability as Ao, SchemaDialect as Ar, integer as As, SourceSqlTypeMap as At, QueryCardinality as Au, CastTarget as B, denseRank as Ba, HookMetadata as Bc, references as Bi, SchemaExpression as Bl, ReturningClause as Bn, ColumnDefaultOf as Bo, UnsafeSchemaSqlExpression as Br, CanonicalLiteral as Bs, TableDefinitions as Bt, SqlTypeOf as Bu, SnapshotIndexTerm as C, offset as Ca, isValidSchemaObjectName as Cc, KeyConstraintOptions as Ci, render as Cl, UpdateAssignmentValue as Cn, between as Co, FromSource as Cr, bigint as Cs, SourceColumns as Ct, NullabilityOf as Cu, SnapshotLiteral as D, ClausePlacement as Da, DriverValueEncoder as Dc, SourceConstraint as Di, QueryValidationIssue as Dl, UpdateFromScope as Dn, isNull as Do, SelectionOutput as Dr, columnResultValue as Ds, SourceKind as Dt, ProvidesOuterOf as Du, SnapshotKeyConstraint as E, AnySelectClause as Ea, AdapterExecutionResult as Ec, ReferentialAction as Ei, QueryValidationErrorCode as El, UpdateFromClause as En, isNotNull as Eo, SelectionObject as Er, column as Es, SourceIdentity as Et, OutputOf as Eu, neutralSnapshotDialect as F, jsonBoolean as Fa, ExplainReadOptions as Fc, catalogCheck as Fi, ExpressionNullability as Fl, MutationReturningClause as Fn, value as Fo, SchemaExpressionErrorCode as Fr, numeric as Fs, exposeColumns as Ft, RequiresOuterMetadataOf as Fu, DialectJson as G, concat as Ga, HookQueryOperation as Gc, AliasedSource as Gi, withDialectCapability as Gl, select as Gn, ColumnHasDefault as Go, renderSchemaSql as Gr, DefaultDescriptor as Gs, TableRow as Gt, isFragment as Gu, DialectCapability as H, rank as Ha, HookOperation as Hc, uniqueConstraint as Hi, isExpression as Hl, ReturningSqlTypes as Hn, ColumnDefinitionConfig as Ho, isUnsafeSchemaSql as Hr, ColumnBehaviorErrorCode as Hs, TableInsertInput as Ht, VisibleDependenciesOf as Hu, schemaSnapshotDialectVersion as I, jsonExists as Ia, ExplainRequest as Ic, catalogForeignKey as Ii, ExpressionOutput as Il, MutationRow as In, mapResult as Io, SchemaExpressionInput as Ir, portableStorage as Is, sourceIdentity as It, RequiresOuterOf as Iu, DialectRowLocking as J, call as Ja, HookTransactionOperation as Jc, QueryAliasIdentity as Ji, ResultDecoder as Jl, ClauseScope as Jn, ColumnInsertInput as Jo, Schema as Jr, ExternalDefaultDescriptor as Js, table as Jt, AnySqlType as Ju, DialectOptions as K, lower as Ka, HookStreamEnd as Kc, LateralIdentity as Ki, DecodableResultType as Kl, AvailableOuterScope as Kn, ColumnHasRuntimeDefault as Ko, schemaExpression as Kr, ExpressionDefaultDescriptor as Ks, TableSqlTypes as Kt, parenthesize as Ku, schemaSnapshotFormat as L, jsonNumber as La, ExplainResult as Lc, check as Li, ExpressionRequires as Ll, MutationScopeValidation as Ln, cast as Lo, SchemaExpressionMode as Lr, text as Ls, AnyTable as Lt, RequiresOuterSourceMeta as Lu, SnapshotTable as M, multiply as Ma, ExplainOptions as Mc, UniqueConstraint as Mi, AnySchemaExpression as Ml, MutationQuery as Mn, SqlCapabilityValidation as Mo, createSchemaDialect as Mr, nativeColumn as Ms, UnknownSourceSqlTypes as Mt, RenderFunction as Mu, SnapshotUniqueConstraint as N, subtract as Na, ExplainOptionsFor as Nc, UniqueConstraintOptions as Ni, Expression as Nl, MutationQueryConfig as Nn, asValue as No, RenderedSchemaExpression as Nr, nativeStorage as Ns, createSource as Nt, RequiresCapabilityMeta as Nu, SnapshotNamingPolicy as O, SelectClause as Oa, ExecutionOptions as Oc, SourceConstraintsRecord as Oi, ColumnDependency as Ol, updateFrom as On, isTrue as Oo, SelectionSqlTypes as Or, date as Os, SourceProvision as Ot, ProvidesOuterSourceMeta as Ou, SnapshotValidationContext as P, JsonPath as Pa, ExplainPlanRow as Pc, UniqueNullSemantics as Pi, ExpressionKind as Pl, MutationReturning as Pn, typedValue as Po, SchemaExpressionError as Pr, nullable as Ps, customSource as Pt, RequiresOf as Pu, NamedCastTarget as Q, count as Qa, QubuExplainableStreamingTransactionalClient as Qc, IndexDialectExtension as Qi, ResultShape as Ql, RequiredScope as Qn, ColumnOptions as Qo, SchemaTableEntry as Qr, GeneratedDescriptor as Qs, nullsFirst as Qt, SqlDate as Qu, schemaSnapshotNamingPolicyVersion as R, jsonPath as Ra, ExplainableQueryAdapter as Rc, foreignKey as Ri, ExpressionSqlType as Rl, MutationSqlTypes as Rn, typedCast as Ro, SchemaRenderContext as Rr, timestamp as Rs, Table as Rt, RequiresSourceMeta as Ru, SnapshotIndex as S, fetchNext as Sa, generatedSchemaObjectName as Sc, KeyConstraint as Si, RenderedQuery as Sl, onConflict as Sn, notLike as So, FromScope as Sr, StorageTypeOf as Ss, Source as St, MetadataOf as Su, SnapshotJsonValue as T, distinct as Ta, materializeSchemaObjectRecord as Tc, PostgresConstraintExtension as Ti, QueryValidationError as Tl, update as Tn, notIn as To, Selection as Tr, boolean as Ts, SourceConstraints as Tt, NullableSourcesOf as Tu, DialectCastTypes as U, rowNumber as Ua, HookOperationKind as Uc, validateConstraintDialect as Ui, makeExpression as Ul, returning as Un, ColumnFromOptions as Uo, normalizeSchemaSql as Ur, ColumnDefault as Us, TableMetadataCallback as Ut, WindowMeta as Uu, Dialect as V, over as Va, HookMetadataValue as Vc, unique as Vi, SchemaExpressionBrand as Vl, ReturningRow as Vn, ColumnDefinition as Vo, defineSchemaExpression as Vr, ColumnBehaviorError as Vs, TableIdentity as Vt, SubqueryMeta as Vu, DialectExplain as W, coalesce as Wa, HookOutcome as Wc, AliasIdentity as Wi, markExpressionCategory as Wl, correlate as Wn, ColumnGeneratedOf as Wo, renderSchemaExpression as Wr, ColumnDefaultInput as Ws, TableOptions as Wt, fragment as Wu, ExplainRenderOptions as X, typedCall as Xa, QubuClient as Xc, alias as Xi, ResultDecodingError as Xl, MissingScope as Xn, ColumnIsNullable as Xo, SchemaNamingPolicy as Xr, GeneratedColumnDescriptor as Xs, asc as Xt, SqlBinary as Xu, ExplainFormat as Y, schemaCall as Ya, OperationEndHook as Yc, QuerySource as Yi, ResultDecoders as Yl, GroupingValidation as Yn, ColumnIsGenerated as Yo, SchemaDiagnostic as Yr, ExternalGeneratedColumnDescriptor as Ys, OrderTerm as Yt, SqlBigInt as Yu, JsonScalarKind as Z, avg as Za, QubuExplainableClient as Zc, lateral as Zi, ResultField as Zl, RequiredOuterScope as Zn, ColumnOnUpdateOf as Zo, SchemaOptions as Zr, GeneratedColumnMode as Zs, desc as Zt, SqlBoolean as Zu, SnapshotExpressionContext as _, where as _a, SchemaObjectIdentity as _c, ForeignKeyConstraint as _i, explain as _l, ExcludedSource as _n, isNotDistinctFrom as _o, leftJoin as _r, PortableStorageType as _s, AnySource as _t, HasAggregate as _u, SnapshotBigInt as a, SqliteIndexExtension as aa, SchemaLiteralValue as ac, SqlOrderCompatible as ad, schema as ai, QubuStreamingTransactionalClient as al, InsertSource as an, TypedSqlTag as ao, cte as ar, ColumnStorageKindOf as as, SchemaLiteralRenderer as at, AnyFragment as au, SnapshotGeneratedColumn as b, rowLock as ba, dialectMismatchDiagnostic as bc, ForeignKeyTarget as bi, RenderCapabilityValidation as bl, doUpdate as bn, lte as bo, groupBy as br, StorageDialectOf as bs, ProvidedSourceIdentity as bt, InheritedMetadata as bu, SnapshotConstraint as c, validateIndexDialect as ca, externalDefault as cc, SqlText as cd, CatalogCheckExpression as ci, QueryAdapter as cl, ValuesSource as cn, exists as co, SetOperator as cr, ColumnStorageTypeOf as cs, resolveCastTarget as ct, CardinalityMeta as cu, SnapshotDefault as d, not as da, identityColumn as dc, SqlTypeSatisfies as dd, CheckConstraintOptions as di, StreamingQueryAdapter as dl, insertSelect as dn, scalar as do, intersect as dr, NativeColumnStorage as ds, QueryConfig as dt, ExpressionMeta as du, IndexTerm as ea, IdentityDialectExtension as ec, SqlEqualityComparable as ed, SchemaTableRecord as ei, QubuHooks as el, order as en, max as eo, SelectCardinality as er, ColumnSqlType as es, PaginationPart as et, dateResultDecoder as eu, SnapshotDiagnostic as f, or as fa, resolveColumnBehavior as fc, SqlUnknown as fd, ConstraintDialectExtension as fi, StreamingTransactionalQueryAdapter as fl, values as fn, ComparisonValidation as fo, union as fr, NativeStorage as fs, QueryKind as ft, Fragment as fu, SnapshotExpression as g, omit as ga, SchemaMetadataValidationError as gc, FieldLikeOptions as gi, executeRows as gl, DoUpdateAction as gn, isDistinctFrom as go, innerJoin as gr, PortableStorageDescriptor as gs, Row as gt, GroupingMeta as gu, SnapshotDialectExtension as h, SelectPart as ha, SchemaMetadataDiagnostic as hc, FieldLike as hi, execute as hl, DoNothingAction as hn, gte as ho, fullJoin as hr, PortableStorage as hs, QueryWithRow as ht, GroupingKeysOf as hu, SchemaSnapshotInput as i, SourceIndexesRecord as ia, ResolvedColumnBehavior as ic, SqlNumericLike as id, generatedTableName as ii, QubuStreamingTransaction as il, InsertSelectSource as in, SqlTag as io, WithClause as ir, ColumnStorageDialectOf as is, RowLockWaitPolicy as it, AggregateMeta as iu, SnapshotStorageContext as j, modulo as ja, ExplainMutationOptions as jc, TableLike as ji, AnyExpression as jl, MutationKind as jn, OperandSqlType as jo, SchemaDialectHooks as jr, json as js, SourceSqlTypes as jt, RenderContext as ju, SnapshotSpecialNumber as k, add as ka, ExecutionRequest as kc, SourceLike as ki, ColumnReference as kl, AllowAllClause as kn, Operand as ko, all as kr, encodeColumnParameter as ks, SourceRow as kt, ProvidesSourceMeta as ku, SnapshotCreateResult as l, DeclaredColumnNullability as la, externalGeneratedColumn as lc, SqlTextLike as ld, CatalogCheckSql as li, QueryExecutor as ll, defaultValues as ln, inQuery as lo, SetQuery as lr, ColumnUpdateInput as ls, AnyQuery as lt, CardinalityOf as lu, SnapshotDialect as m, OmittableSelectClause as ma, SchemaDialectName as mc, ConstraintTiming as mi, TransactionalQueryAdapter as ml, ConflictTarget as mn, gt as mo, crossJoin as mr, PortableColumnStorage as ms, QuerySqlTypeMap as mt, GroupingDependenciesOf as mu, SchemaSnapshot as n, PostgresIndexExtension as na, LiteralDefaultDescriptor as nc, SqlInteger as nd, SchemaValidationError as ni, QubuStreamingClient as nl, deleteFrom as nn, sum as no, CteSource as nr, ColumnStorageDeclarationOf as ns, PortableCastType as nt, timestampResultDecoder as nu, SnapshotCheckConstraint as o, TableIndex as oa, SqliteIdentityExtension as oc, SqlOrderable as od, schemaNamingPolicyVersion as oi, QubuTransaction as ol, InsertValue as on, sql as oo, recursiveCte as or, ColumnStorageOf as os, assertDialectCapability as ot, CapabilitiesOf as ou, SnapshotDiagnosticCode as p, Omit$1 as pa, SchemaDialectExtension as pc, SqlUuid as pd, ConstraintOptions as pi, TransactionOptions as pl, ConflictAction as pn, eq as po, unionAll as pr, NativeStorageDescriptor as ps, QueryRow as pt, FragmentMeta as pu, DialectPagination as q, upper as qa, HookSuccessOutcome as qc, LateralSource as qi, ResultDecodeContext as ql, AvailableScope as qn, ColumnIdentityOf as qo, unsafeSchemaSql as qr, ExpressionGeneratedColumnDescriptor as qs, TableUpdateInput as qt, sequence as qu, SchemaSnapshotAdapter as r, SourceIndex as ra, MysqlIdentityExtension as rc, SqlJson as rd, defaultSchemaNamingPolicy as ri, QubuStreamingExplainableClient as rl, DefaultValuesSource as rn, SqlFragment as ro, RecursiveCteSource as rr, ColumnStorageDescriptor as rs, RowLockMode as rt, AggregateDependenciesOf as ru, SnapshotColumn as s, index as sa, canonicalLiteral as sc, SqlSemanticType as sd, AnyKeyColumn as si, QubuTransactionalClient as sl, InsertValuesRow as sn, caseWhen as so, withCte as sr, ColumnStorageType as ss, createDialect as st, CapabilityMetadataOf as su, AnySchema as t, MysqlIndexExtension as ta, IdentityGeneration as tc, SqlEqualityCompatible as td, SchemaTableRegistry as ti, QubuOptions as tl, orderBy as tn, min as to, SelectQuery as tr, ColumnStorage as ts, PortableCastTarget as tt, jsonTextResultDecoder as tu, SnapshotDecodeResult as u, and as ua, generatedColumn as uc, SqlTimestamp as ud, CheckConstraint as ui, StreamableQuery as ul, insertInto as un, notExists as uo, except as ur, DialectNativeStorage as us, Query as ut, DependenciesOf as uu, SnapshotExtensionContext as v, RowLockClause as va, SchemaObjectNameOptions as vc, ForeignKeyMatch as vi, qubu as vl, OnConflictClause as vn, like as vo, naturalJoin as vr, StorageDeclarationOf as vs, CustomSource as vt, HasSubquery as vu, SnapshotIndexTermExpression as w, having as wa, materializeSchemaObjectIdentity as wc, MysqlConstraintExtension as wi, QueryTypeValidation as wl, UpdateAssignments as wn, inList as wo, from as wr, binary as ws, SourceConfig as wt, NullableSourceMeta as wu, SnapshotIdentity as x, fetchFirst as xa, freezeSchemaMetadata as xc, ForeignKeyTargetInput as xi, RenderOptions as xl, excluded as xn, ne as xo, FromClause as xr, StorageOf as xs, ProvidedSourceRow as xt, InheritedMetadataOf as xu, SnapshotForeignKey as y, RowLockOptions as ya, assertSchemaDialectSupport as yc, ForeignKeyOptions as yi, stream as yl, doNothing as yn, lt as yo, rightJoin as yr, StorageDescriptor as ys, CustomSourceOptions as yt, HasWindow as yu, schemaSnapshotVersion as z, jsonText as za, HookErrorOutcome as zc, primaryKey as zi, ExpressionWithOutput as zl, allowAll as zn, ColumnCodec as zo, SchemaRenderOptions as zr, uuid as zs, TableColumns as zt, ResultMeta as zu };
+export { CompleteSnapshotExtension as $, IndexDialectExtension as $a, GeneratedColumnDescriptor as $c, isFragment as $d, SchemaTableEntry as $i, HookTransactionOperation as $l, DefaultValuesSource as $n, avg as $o, RequiredScope as $r, ColumnOnUpdateOf as $s, assertDialectCapability as $t, ResultDecodeContext as $u, SnapshotStorage as A, SourceLike as Aa, columnSqlType as Ac, MetadataOf as Ad, all as Ai, materializeSchemaObjectRecord as Al, sourceIdentity as An, SelectClause as Ao, AllowAllClause as Ar, isTrue as As, schemaSnapshotCompleteVersion as At, QueryTypeValidation as Au, CompleteSchemaSnapshot as B, primaryKey as Ba, text as Bc, RenderFunction as Bd, SchemaRenderOptions as Bi, ExplainReadOptions as Bl, TableSqlTypes as Bn, jsonPath as Bo, allowAll as Br, typedCast as Bs, DialectPagination as Bt, ExpressionKind as Bu, SnapshotIndexTerm as C, KeyConstraint as Ca, StorageOf as Cc, GroupingKeysOf as Cd, FromScope as Ci, SchemaObjectNameOptions as Cl, SourceRow as Cn, fetchFirst as Co, onDuplicateKeyUpdate as Cr, ne as Cs, CompleteSnapshotValueFact as Ct, explain as Cu, SnapshotLiteral as D, ReferentialAction as Da, boolean as Dc, HasWindow as Dd, SelectionObject as Di, generatedSchemaObjectName as Dl, createSource as Dn, distinct as Do, UpdateFromClause as Dr, notIn as Ds, SchemaSnapshotV1Input as Dt, RenderOptions as Du, SnapshotKeyConstraint as E, PostgresConstraintExtension as Ea, binary as Ec, HasSubquery as Ed, Selection as Ei, freezeSchemaMetadata as El, UnknownSourceSqlTypes as En, having as Eo, update as Er, inList as Es, SchemaSnapshotV1DecodeResult as Et, RenderCapabilityValidation as Eu, neutralSnapshotDialect as F, UniqueNullSemantics as Fa, nativeColumn as Fc, ProvidesOuterOf as Fd, SchemaExpressionError as Fi, ExecutionResult as Fl, TableIdentity as Fn, subtract as Fo, MutationReturning as Fr, asValue as Fs, DialectCapability as Ft, ColumnReference as Fu, CompleteSnapshotColumn as G, AliasIdentity as Ga, ColumnBehaviorErrorCode as Gc, RequiresOuterSourceMeta as Gd, renderSchemaExpression as Gi, HookMetadata as Gl, desc as Gn, rowNumber as Go, correlate as Gr, ColumnFromOptions as Gs, NamedCastTarget as Gt, ExpressionWithOutput as Gu, CompleteSnapshotCapabilities as H, unique as Ha, uuid as Hc, RequiresOf as Hd, defineSchemaExpression as Hi, ExplainResult as Hl, table as Hn, denseRank as Ho, ReturningRow as Hr, ColumnDefaultOf as Hs, ExplainFormat as Ht, ExpressionOutput as Hu, schemaSnapshotDialectVersion as I, catalogCheck as Ia, nativeStorage as Ic, ProvidesOuterSourceMeta as Id, SchemaExpressionErrorCode as Ii, ExplainMutationOptions as Il, TableInsertInput as In, JsonPath as Io, MutationReturningClause as Ir, typedValue as Is, DialectCastTypes as It, expressionFragment as Iu, CompleteSnapshotCreateResult as J, LateralSource as Ja, DefaultDescriptor as Jc, SqlTypeOf as Jd, unsafeSchemaSql as Ji, HookOperationKind as Jl, order as Jn, lower as Jo, AvailableScope as Jr, ColumnHasRuntimeDefault as Js, PortableCastTarget as Jt, isExpression as Ju, CompleteSnapshotComment as K, AliasedSource as Ka, ColumnDefault as Kc, RequiresSourceMeta as Kd, renderSchemaSql as Ki, HookMetadataValue as Kl, nullsFirst as Kn, coalesce as Ko, select as Kr, ColumnGeneratedOf as Ks, PaginationKind as Kt, SchemaExpression as Ku, schemaSnapshotFormat as L, catalogForeignKey as La, nullable as Lc, ProvidesSourceMeta as Ld, SchemaExpressionInput as Li, ExplainOptions as Ll, TableMetadataCallback as Ln, jsonBoolean as Lo, MutationRow as Lr, value as Ls, DialectExplain as Lt, AnyExpression as Lu, SnapshotTable as M, TableLike as Ma, encodeColumnParameter as Mc, NullableSourceMeta as Md, SchemaDialectHooks as Mi, DriverValueEncoder as Ml, Table as Mn, divide as Mo, MutationKind as Mr, OperandNullability as Ms, schemaSnapshotVersion1 as Mt, QueryValidationErrorCode as Mu, SnapshotUniqueConstraint as N, UniqueConstraint as Na, integer as Nc, NullableSourcesOf as Nd, createSchemaDialect as Ni, ExecutionOptions as Nl, TableColumns as Nn, modulo as No, MutationQuery as Nr, OperandSqlType as Ns, CastTarget as Nt, QueryValidationIssue as Nu, SnapshotNamingPolicy as O, SourceConstraint as Oa, column as Oc, InheritedMetadata as Od, SelectionOutput as Oi, isValidSchemaObjectName as Ol, customSource as On, AnySelectClause as Oo, UpdateFromScope as Or, isNotNull as Os, completeSchemaSnapshotFormat as Ot, RenderedQuery as Ou, SnapshotValidationContext as P, UniqueConstraintOptions as Pa, json as Pc, OutputOf as Pd, RenderedSchemaExpression as Pi, ExecutionRequest as Pl, TableDefinitions as Pn, multiply as Po, MutationQueryConfig as Pr, SqlCapabilityValidation as Ps, Dialect as Pt, ColumnDependency as Pu, CompleteSnapshotEnum as Q, lateral as Qa, ExternalGeneratedColumnDescriptor as Qc, fragment as Qd, SchemaOptions as Qi, HookSuccessOutcome as Ql, deleteFrom as Qn, typedCall as Qo, RequiredOuterScope as Qr, ColumnIsNullable as Qs, SchemaLiteralRenderer as Qt, DecodableResultType as Qu, schemaSnapshotNamingPolicyVersion as R, check as Ra, numeric as Rc, QueryCardinality as Rd, SchemaExpressionMode as Ri, ExplainOptionsFor as Rl, TableOptions as Rn, jsonExists as Ro, MutationScopeValidation as Rr, mapResult as Rs, DialectJson as Rt, AnySchemaExpression as Ru, SnapshotIndex as S, ForeignKeyTargetInput as Sa, StorageDialectOf as Sc, GroupingDependenciesOf as Sd, SqlUuid as Sf, FromClause as Si, SchemaObjectIdentity as Sl, SourceProvision as Sn, rowLock as So, incoming as Sr, lte as Ss, CompleteSnapshotTrigger as St, executeRows as Su, SnapshotJsonValue as T, MysqlConstraintExtension as Ta, bigint as Tc, HasAggregate as Td, from as Ti, dialectMismatchDiagnostic as Tl, SourceSqlTypes as Tn, offset as To, UpdateAssignments as Tr, between as Ts, SchemaSnapshotV1 as Tt, stream as Tu, CompleteSnapshotCheckConstraint as U, uniqueConstraint as Ua, CanonicalLiteral as Uc, RequiresOuterMetadataOf as Ud, isUnsafeSchemaSql as Ui, ExplainableQueryAdapter as Ul, OrderTerm as Un, over as Uo, ReturningSqlTypes as Ur, ColumnDefinition as Us, ExplainRenderOptions as Ut, ExpressionRequires as Uu, CompleteSchemaSnapshotInput as V, references as Va, timestamp as Vc, RequiresCapabilityMeta as Vd, UnsafeSchemaSqlExpression as Vi, ExplainRequest as Vl, TableUpdateInput as Vn, jsonText as Vo, ReturningClause as Vr, ColumnCodec as Vs, DialectRowLocking as Vt, ExpressionNullability as Vu, CompleteSnapshotCollation as W, validateConstraintDialect as Wa, ColumnBehaviorError as Wc, RequiresOuterOf as Wd, normalizeSchemaSql as Wi, HookErrorOutcome as Wl, asc as Wn, rank as Wo, returning as Wr, ColumnDefinitionConfig as Ws, JsonScalarKind as Wt, ExpressionSqlType as Wu, CompleteSnapshotDeferredObject as X, QuerySource as Xa, ExpressionGeneratedColumnDescriptor as Xc, VisibleDependenciesOf as Xd, SchemaDiagnostic as Xi, HookQueryOperation as Xl, jsonArrayFrom as Xn, call as Xo, GroupingValidation as Xr, ColumnInsertInput as Xs, RowLockMode as Xt, markExpressionCategory as Xu, CompleteSnapshotDecodeResult as Y, QueryAliasIdentity as Ya, ExpressionDefaultDescriptor as Yc, SubqueryMeta as Yd, Schema as Yi, HookOutcome as Yl, orderBy as Yn, upper as Yo, ClauseScope as Yr, ColumnIdentityOf as Ys, PortableCastType as Yt, makeExpression as Yu, CompleteSnapshotDomain as Z, alias as Za, ExternalDefaultDescriptor as Zc, WindowMeta as Zd, SchemaNamingPolicy as Zi, HookStreamEnd as Zl, jsonObjectFrom as Zn, schemaCall as Zo, MissingScope as Zr, ColumnIsGenerated as Zs, RowLockWaitPolicy as Zt, withDialectCapability as Zu, SnapshotExpressionContext as _, FieldLikeOptions as _a, PortableStorage as _c, CardinalityOf as _d, SqlTextLike as _f, innerJoin as _i, resolveColumnBehavior as _l, SourceColumns as _n, SelectPart as _o, excluded as _r, gte as _s, CompleteSnapshotProvenance as _t, StreamingQueryAdapter as _u, SnapshotBigInt as a, generatedTableName as aa, ColumnStorageDescriptor as ac, bigintResultDecoder as ad, SqlBoolean as af, WithClause as ai, IdentityOptionValue as al, QueryConfig as an, SourceIndex as ao, defaultValues as ar, SqlFragment as as, CompleteSnapshotNamespace as at, QubuExplainableTransactionalClient as au, SnapshotGeneratedColumn as b, ForeignKeyOptions as ba, StorageDeclarationOf as bc, Fragment as bd, SqlTypeSatisfies as bf, rightJoin as bi, SchemaMetadataDiagnostic as bl, SourceIdentity as bn, RowLockClause as bo, IncomingIdentity as br, like as bs, CompleteSnapshotSequence as bt, TransactionalQueryAdapter as bu, SnapshotConstraint as c, AnyKeyColumn as ca, ColumnStorageOf as cc, jsonTextResultDecoder as cd, SqlEqualityComparable as cf, withCte as ci, MysqlIdentityExtension as cl, QuerySqlTypeMap as cn, TableIndex as co, values as cr, sql as cs, CompleteSnapshotObjectMetadata as ct, QubuStreamingClient as cu, SnapshotDefault as d, CheckConstraint as da, ColumnUpdateInput as dc, AggregateDependenciesOf as dd, SqlJson as df, except as di, SqliteIdentityExtension as dl, AnySource as dn, DeclaredColumnNullability as do, DoNothingAction as dr, inQuery as ds, CompleteSnapshotObjectReference as dt, QubuStreamingTransactionalClient as du, SchemaTableNames as ea, ColumnOptions as ec, ResultDecoder as ed, parenthesize as ef, ScopeValidation as ei, GeneratedColumnMode as el, createDialect as en, IndexOptions as eo, InsertSelectSource as er, count as es, CompleteSnapshotForeignKey as et, NestedTransactionalQueryAdapter as eu, SnapshotDiagnostic as f, CheckConstraintOptions as fa, DialectNativeStorage as fc, AggregateMeta as fd, SqlNumericLike as ff, intersect as fi, canonicalLiteral as fl, CustomSource as fn, and as fo, DoUpdateAction as fr, notExists as fs, CompleteSnapshotOpaqueObject as ft, QubuTransaction as fu, SnapshotExpression as g, FieldLike as ga, PortableColumnStorage as gc, CardinalityMeta as gd, SqlText as gf, fullJoin as gi, identityColumn as gl, Source as gn, OmittableSelectClause as go, doUpdate as gr, gt as gs, CompleteSnapshotPolicy as gt, StreamableQuery as gu, SnapshotDialectExtension as h, ConstraintTiming as ha, NativeStorageDescriptor as hc, CapabilityMetadataOf as hd, SqlSemanticType as hf, crossJoin as hi, generatedColumn as hl, ProvidedSourceRow as hn, Omit$1 as ho, doNothing as hr, eq as hs, CompleteSnapshotPhysicalReference as ht, QueryExecutor as hu, SchemaSnapshotInput as i, defaultSchemaNamingPolicy as ia, ColumnStorageDeclarationOf as ic, ResultShape as id, SqlBinary as if, RecursiveCteSource as ii, IdentityGeneration as il, Query as in, PostgresIndexExtension as io, ValuesSource as ir, sum as is, CompleteSnapshotKeyConstraint as it, QubuExplainableStreamingTransactionalClient as iu, SnapshotStorageContext as j, SqliteConstraintExtension as ja, date as jc, NullabilityOf as jd, SchemaDialect as ji, AdapterExecutionResult as jl, AnyTable as jn, add as jo, MutationClause as jr, Operand as js, schemaSnapshotV1Version as jt, QueryValidationError as ju, SnapshotSpecialNumber as k, SourceConstraintsRecord as ka, columnResultValue as kc, InheritedMetadataOf as kd, SelectionSqlTypes as ki, materializeSchemaObjectIdentity as kl, exposeColumns as kn, ClausePlacement as ko, updateFrom as kr, isNull as ks, completeSchemaSnapshotVersion as kt, render as ku, SnapshotCreateResult as l, CatalogCheckExpression as la, ColumnStorageType as lc, resultValue as ld, SqlEqualityCompatible as lf, SetOperator as li, ResolvedColumnBehavior as ll, QueryWithRow as ln, index as lo, ConflictAction as lr, caseWhen as ls, CompleteSnapshotObjectOwner as lt, QubuStreamingExplainableClient as lu, SnapshotDialect as m, ConstraintOptions as ma, NativeStorage as mc, CapabilitiesOf as md, SqlOrderable as mf, unionAll as mi, externalGeneratedColumn as ml, ProvidedSourceIdentity as mn, or as mo, OnConflictClause as mr, ComparisonValidation as ms, CompleteSnapshotPartition as mt, QueryAdapter as mu, SchemaSnapshot as n, SchemaTableRegistry as na, ColumnSqlType as nc, ResultDecodingError as nd, AnySqlType as nf, SelectQuery as ni, IdentityDescriptor as nl, resolveCastTarget as nn, IndexTermOptions as no, InsertValue as nr, max as ns, CompleteSnapshotIndex as nt, QubuClient as nu, SnapshotCheckConstraint as o, schema as oa, ColumnStorageDialectOf as oc, booleanResultDecoder as od, SqlDate as of, cte as oi, IdentityOptions as ol, QueryKind as on, SourceIndexesRecord as oo, insertInto as or, SqlTag as os, CompleteSnapshotObject as ot, QubuHooks as ou, SnapshotDiagnosticCode as p, ConstraintDialectExtension as pa, NativeColumnStorage as pc, AnyFragment as pd, SqlOrderCompatible as pf, union as pi, externalDefault as pl, CustomSourceOptions as pn, not as po, ExcludedSource as pr, scalar as ps, CompleteSnapshotOwnership as pt, QubuTransactionalClient as pu, CompleteSnapshotConstraint as q, LateralIdentity as qa, ColumnDefaultInput as qc, ResultMeta as qd, schemaExpression as qi, HookOperation as ql, nullsLast as qn, concat as qo, AvailableOuterScope as qr, ColumnHasDefault as qs, PaginationPart as qt, SchemaExpressionBrand as qu, SchemaSnapshotAdapter as r, SchemaValidationError as ra, ColumnStorage as rc, ResultField as rd, SqlBigInt as rf, CteSource as ri, IdentityDialectExtension as rl, AnyQuery as rn, MysqlIndexExtension as ro, InsertValuesRow as rr, min as rs, CompleteSnapshotIndexTerm as rt, QubuExplainableClient as ru, SnapshotColumn as s, schemaNamingPolicyVersion as sa, ColumnStorageKindOf as sc, dateResultDecoder as sd, SqlDecimal as sf, recursiveCte as si, LiteralDefaultDescriptor as sl, QueryRow as sn, SqliteIndexExtension as so, insertSelect as sr, TypedSqlTag as ss, CompleteSnapshotObjectKind as st, QubuOptions as su, AnySchema as t, SchemaTableRecord as ta, ColumnOutput as tc, ResultDecoders as td, sequence as tf, SelectCardinality as ti, GeneratedDescriptor as tl, extendDialect as tn, IndexTerm as to, InsertSource as tr, countDistinct as ts, CompleteSnapshotIdentity as tt, OperationEndHook as tu, SnapshotDecodeResult as u, CatalogCheckSql as ua, ColumnStorageTypeOf as uc, timestampResultDecoder as ud, SqlInteger as uf, SetQuery as ui, SchemaLiteralValue as ul, Row as un, validateIndexDialect as uo, ConflictTarget as ur, exists as us, CompleteSnapshotObjectOwnerKind as ut, QubuStreamingTransaction as uu, SnapshotExtensionContext as v, ForeignKeyConstraint as va, PortableStorageDescriptor as vc, DependenciesOf as vd, SqlTimestamp as vf, leftJoin as vi, SchemaDialectExtension as vl, SourceConfig as vn, omit as vo, onConflict as vr, isDistinctFrom as vs, CompleteSnapshotRoutine as vt, StreamingTransactionalQueryAdapter as vu, SnapshotIndexTermExpression as w, KeyConstraintOptions as wa, StorageTypeOf as wc, GroupingMeta as wd, FromSource as wi, assertSchemaDialectSupport as wl, SourceSqlTypeMap as wn, fetchNext as wo, UpdateAssignmentValue as wr, notLike as ws, CompleteSnapshotView as wt, qubu as wu, SnapshotIdentity as x, ForeignKeyTarget as xa, StorageDescriptor as xc, FragmentMeta as xd, SqlUnknown as xf, groupBy as xi, SchemaMetadataValidationError as xl, SourceKind as xn, RowLockOptions as xo, OnDuplicateKeyUpdateClause as xr, lt as xs, CompleteSnapshotTable as xt, execute as xu, SnapshotForeignKey as y, ForeignKeyMatch as ya, PortableStorageType as yc, ExpressionMeta as yd, SqlTypeName as yf, naturalJoin as yi, SchemaDialectName as yl, SourceConstraints as yn, where as yo, IncomingColumns as yr, isNotDistinctFrom as ys, CompleteSnapshotRoutineParameter as yt, TransactionOptions as yu, schemaSnapshotVersion as z, foreignKey as za, portableStorage as zc, RenderContext as zd, SchemaRenderContext as zi, ExplainPlanRow as zl, TableRow as zn, jsonNumber as zo, MutationSqlTypes as zr, cast as zs, DialectOptions as zt, Expression as zu };