qubu 0.4.2 → 0.4.3

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

@@ -415,15 +415,23 @@ declare function render<TQuery extends AnyFragment, TCapabilities extends Dialec
 type StreamableQuery<TRow extends object = Record<string, unknown>> = QueryWithRow<TRow> & {
   readonly queryKind: "select" | "set";
 };
+/** Scalar application metadata forwarded only to bound-client lifecycle hooks. */
+type HookMetadataValue = string | number | boolean;
+/** Application correlation metadata forwarded without affecting execution. */
+type HookMetadata = Readonly<Record<string, HookMetadataValue>>;
 /** Rendering policy and cancellation input accepted by query execution. */
 interface ExecutionOptions extends RenderOptions {
   /** Passed to the application adapter for drivers that support cancellation. */
   readonly signal?: AbortSignal;
+  /** Inert application metadata exposed to bound-client hooks. */
+  readonly hookMetadata?: HookMetadata;
 }
 /** Rendering, EXPLAIN, and cancellation options for plan requests. */
 interface ExplainOptions extends RenderOptions, ExplainRenderOptions {
   /** Passed to the application adapter for drivers that support cancellation. */
   readonly signal?: AbortSignal;
+  /** Inert application metadata exposed to bound-client hooks. */
+  readonly hookMetadata?: HookMetadata;
 }
 /** EXPLAIN options accepted for SELECT and set-operation queries. */
 type ExplainReadOptions = ExplainOptions;
@@ -437,6 +445,66 @@ type ExplainOptionsFor<TQuery extends AnyQuery> = TQuery["queryKind"] extends "s
 interface TransactionOptions {
   /** Passed to the adapter for transaction begin, commit, and rollback. */
   readonly signal?: AbortSignal;
+  /** Inert application metadata exposed to bound-client hooks. */
+  readonly hookMetadata?: HookMetadata;
+}
+/** Operations observable through one bound client's hooks. */
+type HookOperationKind = "execute" | "stream" | "explain" | "transaction";
+interface HookOperationBase {
+  /** Opaque identifier unique within one bound client and its transaction scopes. */
+  readonly id: number;
+  /** The enclosing transaction operation, when present. */
+  readonly parentId?: number;
+  readonly kind: HookOperationKind;
+  /** Monotonic start time in milliseconds. */
+  readonly startedAt: number;
+  readonly metadata?: HookMetadata;
+}
+/** Metadata for one bound-client query operation. */
+interface HookQueryOperation extends HookOperationBase {
+  readonly kind: "execute" | "stream" | "explain";
+  readonly queryKind: QueryKind;
+  readonly dialect: string;
+  readonly sql: string;
+  readonly parameterCount: number;
+}
+/** Metadata for one bound-client transaction operation. */
+interface HookTransactionOperation extends HookOperationBase {
+  readonly kind: "transaction";
+}
+/** Immutable metadata supplied when a bound-client operation starts. */
+type HookOperation = HookQueryOperation | HookTransactionOperation;
+/** How a successfully observed stream stopped producing rows. */
+type HookStreamEnd = "complete" | "consumer-return";
+/** Aggregate facts reported after a successful bound-client operation. */
+interface HookSuccessOutcome {
+  readonly status: "success";
+  readonly durationMs: number;
+  readonly rowCount?: number;
+  readonly affectedRows?: number | bigint;
+  readonly changedRows?: number | bigint;
+  readonly hasInsertId?: boolean;
+  readonly streamEnd?: HookStreamEnd;
+}
+/** The original failure reported after a bound-client operation rejects or throws. */
+interface HookErrorOutcome {
+  readonly status: "error";
+  readonly durationMs: number;
+  readonly error: unknown;
+}
+/** Terminal observation for one bound-client operation. */
+type HookOutcome = HookSuccessOutcome | HookErrorOutcome;
+/** Optional completion callback returned when an operation starts. */
+type OperationEndHook = (outcome: HookOutcome) => void;
+/** Observational callbacks for one bound client and its transaction scopes. */
+interface QubuHooks {
+  onOperationStart?(operation: HookOperation): OperationEndHook | void;
+  /** Receives hook failures without changing the observed operation's outcome. */
+  onHookError?(error: unknown): void;
+}
+/** Optional lifecycle observation configured for one bound client. */
+interface QubuOptions {
+  readonly hooks?: QubuHooks;
 }
 /** One rendered statement and the controls passed to an application adapter. */
 interface ExecutionRequest {
@@ -570,16 +638,16 @@ 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 ExplainableQueryAdapter & StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableStreamingTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter> & QubuStreamingExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & TransactionalQueryAdapter>(adapter: TAdapter): QubuExplainableTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter): QubuExplainableClient<TAdapter>;
-declare function qubu<TAdapter extends StreamingTransactionalQueryAdapter>(adapter: TAdapter): QubuStreamingTransactionalClient<TAdapter>;
-declare function qubu<TAdapter extends TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter> & QubuStreamingClient<TAdapter>;
-declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdapter): QubuTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
-declare function qubu<TAdapter extends StreamingQueryAdapter>(adapter: TAdapter): QubuStreamingClient<TAdapter>;
-declare function qubu<TAdapter extends QueryAdapter>(adapter: TAdapter): QubuClient<TAdapter>;
+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>>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuStreamingExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends ExplainableQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuExplainableClient<TAdapter>;
+declare function qubu<TAdapter extends StreamingTransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuStreamingTransactionalClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter & StreamingQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuTransactionalClient<TAdapter> & QubuStreamingClient<TAdapter>;
+declare function qubu<TAdapter extends TransactionalQueryAdapter>(adapter: TAdapter, options?: QubuOptions): QubuTransactionalClient<TAdapter, TransactionAdapterOf<TAdapter>>;
+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;
@@ -750,7 +818,7 @@ interface IdentityDescriptor {
   readonly dialect?: IdentityDialectExtension;
 }
 /** Structured failures raised while resolving column behavior metadata. */
-type ColumnBehaviorErrorCode = "invalid-default" | "invalid-generated-column" | "invalid-identity" | "invalid-on-update" | "default-flag-conflict" | "generated-flag-conflict" | "default-generated-conflict" | "identity-generated-conflict";
+type ColumnBehaviorErrorCode = "invalid-default" | "invalid-runtime-default" | "invalid-generated-column" | "invalid-identity" | "invalid-on-update" | "default-flag-conflict" | "generated-flag-conflict" | "default-generated-conflict" | "identity-generated-conflict" | "runtime-default-generated-conflict";
 /** A column behavior error with a stable code and optional property path. */
 declare class ColumnBehaviorError extends TypeError {
   readonly code: ColumnBehaviorErrorCode;
@@ -774,8 +842,10 @@ declare function identityColumn(generation?: IdentityGeneration, options?: {
 /** The normalized behavior fields attached to a column definition. */
 interface ResolvedColumnBehavior {
   readonly hasDefault: boolean;
+  readonly hasRuntimeDefault: boolean;
   readonly generated: boolean;
   readonly default?: ColumnDefault;
+  readonly defaultFn?: () => unknown;
   readonly generatedColumn?: GeneratedColumnDescriptor;
   readonly identity?: IdentityDescriptor;
   readonly onUpdate?: AnySchemaExpression;
@@ -783,6 +853,7 @@ interface ResolvedColumnBehavior {
 /** Normalize complete and legacy column behavior into immutable metadata. */
 declare function resolveColumnBehavior(options: {
   readonly hasDefault?: boolean;
+  readonly defaultFn?: () => unknown;
   readonly generated?: boolean;
   readonly default?: ColumnDefaultInput;
   readonly generatedColumn?: GeneratedColumnDescriptor;
@@ -859,12 +930,19 @@ type StorageTypeOf<T> = ColumnStorageTypeOf<T>;
 type StorageDialectOf<T> = ColumnStorageDialectOf<T>;
 /** Alias for the native declaration extraction. */
 type StorageDeclarationOf<T> = ColumnStorageDeclarationOf<T>;
-interface ColumnOptions {
+/** Live conversion between one column's application and physical driver values. */
+interface ColumnCodec<TOutput = unknown, TInsert = TOutput, TDriver = unknown> {
+  readonly toDriver: (value: TInsert) => TDriver;
+  readonly fromDriver: (value: TDriver) => TOutput;
+}
+interface ColumnOptions<TOutput = unknown, TInsert = TOutput> {
   readonly nullable?: boolean;
   readonly hasDefault?: boolean;
   readonly generated?: boolean;
   /** A literal, deterministic expression, or externally managed default. */
   readonly default?: ColumnDefaultInput;
+  /** Supply an application value when an insert omits this column. */
+  readonly defaultFn?: () => TInsert;
   /** Complete generated-column metadata, independent of identity behavior. */
   readonly generatedColumn?: GeneratedColumnDescriptor;
   /** Database identity metadata; identity is not an ordinary expression. */
@@ -877,13 +955,15 @@ interface ColumnOptions {
   readonly storage?: ColumnStorage;
   /** 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. */
+  readonly codec?: ColumnCodec<TOutput, TInsert, unknown>;
   /**
    * Raw SQL target that makes a custom definition reusable with cast(). The value is emitted
    * verbatim and must come from trusted source code.
    */
   readonly castType?: string;
 }
-type BuiltInColumnOptions = Omit<ColumnOptions, "castType" | "storage"> & {
+type BuiltInColumnOptions<TOutput> = Omit<ColumnOptions<TOutput, TOutput>, "castType" | "storage"> & {
   readonly castType?: never;
   readonly storage?: never;
 };
@@ -899,6 +979,8 @@ interface ColumnDefinitionConfig {
   readonly update?: unknown;
   /** Whether an insert may omit the column. Defaults to `false`. */
   readonly hasDefault?: boolean;
+  /** Whether an application runtime default can supply an omitted insert. */
+  readonly hasRuntimeDefault?: boolean;
   /** Whether the database generates the column. Defaults to `false`. */
   readonly generated?: boolean;
   /** SQL semantic domain. Defaults to {@link SqlUnknown}. */
@@ -921,6 +1003,7 @@ type ColumnConfigNullable<TConfig> = ConfigBoolean<TConfig, "nullable">;
 type ColumnConfigInsert<TConfig> = ConfigValue<TConfig, "insert", ColumnConfigOutput<TConfig>>;
 type ColumnConfigUpdate<TConfig> = ConfigValue<TConfig, "update", ColumnConfigInsert<TConfig>>;
 type ColumnConfigHasDefault<TConfig> = ConfigBoolean<TConfig, "hasDefault">;
+type ColumnConfigHasRuntimeDefault<TConfig> = ConfigBoolean<TConfig, "hasRuntimeDefault">;
 type ColumnConfigGenerated<TConfig> = ConfigBoolean<TConfig, "generated">;
 type ColumnConfigSqlType<TConfig> = Extract<ConfigValue<TConfig, "sqlType", SqlUnknown>, AnySqlType> extends (infer TValue) ? [TValue] extends [never] ? SqlUnknown : TValue : SqlUnknown;
 type ColumnConfigStorage<TConfig> = ConfigValue<TConfig, "storage", undefined>;
@@ -939,6 +1022,7 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   readonly definitionKind: "column";
   readonly nullable: ColumnConfigNullable<TConfig>;
   readonly hasDefault: ColumnConfigHasDefault<TConfig>;
+  readonly hasRuntimeDefault: ColumnConfigHasRuntimeDefault<TConfig>;
   readonly generated: ColumnConfigGenerated<TConfig>;
   /** Complete database default metadata, when known. */
   readonly default?: ColumnConfigDefault<TConfig>;
@@ -953,6 +1037,12 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
   readonly storage?: ColumnConfigStorage<TConfig>;
   /** Runtime decoder used when this definition is projected. */
   readonly resultDecoder?: ResultDecoder;
+  /** Runtime default used when an application insert omits this definition. */
+  readonly defaultFn?: () => ColumnConfigInsert<TConfig>;
+  /** Runtime encoder applied to application values written through this definition. */
+  readonly parameterEncoder?: (value: ColumnConfigInsert<TConfig>) => unknown;
+  /** Live application/driver codec available to integration adapters. */
+  readonly columnCodec?: ColumnCodec<ColumnConfigOutput<TConfig>, ColumnConfigInsert<TConfig>, unknown>;
   /** Runtime CAST target when this definition can describe a cast result. */
   readonly castTarget?: CastTarget;
   readonly __output?: ColumnConfigOutput<TConfig>;
@@ -974,22 +1064,25 @@ interface ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> {
 }
 type Flag<T extends boolean | undefined> = T extends true ? true : false;
 type HasExplicitOption<TOptions, TKey extends PropertyKey> = TKey extends keyof TOptions ? {} extends Pick<TOptions, TKey> ? false : true : false;
-type ColumnHasDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, "default"> extends true ? true : Flag<TOptions["hasDefault"]>;
-type ColumnIsGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
+type ColumnHasDefaultOption<TOptions extends ColumnOptions<any, any>> = HasExplicitOption<TOptions, "default"> extends true ? true : Flag<TOptions["hasDefault"]>;
+type ColumnHasRuntimeDefaultOption<TOptions extends ColumnOptions<any, any>> = TOptions extends {
+  readonly defaultFn: () => unknown;
+} ? true : false;
+type ColumnIsGeneratedOption<TOptions extends ColumnOptions<any, any>> = TOptions extends {
   readonly generatedColumn: GeneratedColumnDescriptor;
 } ? true : TOptions extends {
   readonly identity: IdentityDescriptor;
 } ? true : Flag<TOptions["generated"]>;
-type ColumnDefaultOption<TOptions extends ColumnOptions> = HasExplicitOption<TOptions, "default"> extends true ? TOptions extends {
+type ColumnDefaultOption<TOptions extends ColumnOptions<any, any>> = HasExplicitOption<TOptions, "default"> extends true ? TOptions extends {
   readonly default: infer TDefault;
 } ? TDefault extends AnySchemaExpression ? ExpressionDefaultDescriptor<TDefault> : TDefault extends ExternalDefaultDescriptor ? TDefault : TDefault extends SchemaLiteralValue ? LiteralDefaultDescriptor : never : never : TOptions["hasDefault"] extends true ? ExternalDefaultDescriptor : undefined;
-type ColumnGeneratedOption<TOptions extends ColumnOptions> = TOptions extends {
+type ColumnGeneratedOption<TOptions extends ColumnOptions<any, any>> = TOptions extends {
   readonly generatedColumn: infer TGenerated extends GeneratedColumnDescriptor;
 } ? TGenerated : TOptions["generated"] extends true ? ExternalGeneratedColumnDescriptor : undefined;
-type ColumnIdentityOption<TOptions extends ColumnOptions> = TOptions extends {
+type ColumnIdentityOption<TOptions extends ColumnOptions<any, any>> = TOptions extends {
   readonly identity: infer TIdentity extends IdentityDescriptor;
 } ? TIdentity : undefined;
-type ColumnOnUpdateOption<TOptions extends ColumnOptions> = TOptions extends {
+type ColumnOnUpdateOption<TOptions extends ColumnOptions<any, any>> = TOptions extends {
   readonly onUpdate: infer TOnUpdate extends AnySchemaExpression;
 } ? TOnUpdate : undefined;
 type IsAny<T> = 0 extends 1 & T ? true : false;
@@ -1004,19 +1097,19 @@ type ColumnValueConfig<TOutput, TInsert, TUpdate> = {
 });
 type TrueConfig<TKey extends PropertyKey, TValue> = TValue extends true ? { readonly [TField in TKey]: true; } : {};
 type DefinedConfig<TKey extends PropertyKey, TValue> = [TValue] extends [undefined] ? {} : { readonly [TField in TKey]: TValue; };
-type ColumnOptionConfig<TOptions extends ColumnOptions> = Simplify$1<TrueConfig<"nullable", Flag<TOptions["nullable"]>> & TrueConfig<"hasDefault", ColumnHasDefaultOption<TOptions>> & TrueConfig<"generated", ColumnIsGeneratedOption<TOptions>> & DefinedConfig<"default", ColumnDefaultOption<TOptions>> & DefinedConfig<"generatedColumn", ColumnGeneratedOption<TOptions>> & DefinedConfig<"identity", ColumnIdentityOption<TOptions>> & DefinedConfig<"onUpdate", ColumnOnUpdateOption<TOptions>> & (TOptions extends {
+type ColumnOptionConfig<TOptions extends ColumnOptions<any, any>> = Simplify$1<TrueConfig<"nullable", Flag<TOptions["nullable"]>> & TrueConfig<"hasDefault", ColumnHasDefaultOption<TOptions>> & TrueConfig<"hasRuntimeDefault", ColumnHasRuntimeDefaultOption<TOptions>> & TrueConfig<"generated", ColumnIsGeneratedOption<TOptions>> & DefinedConfig<"default", ColumnDefaultOption<TOptions>> & DefinedConfig<"generatedColumn", ColumnGeneratedOption<TOptions>> & DefinedConfig<"identity", ColumnIdentityOption<TOptions>> & DefinedConfig<"onUpdate", ColumnOnUpdateOption<TOptions>> & (TOptions extends {
   readonly storage: infer TStorage extends ColumnStorage;
 } ? {
   readonly storage: TStorage;
 } : {})>;
-type BuiltInColumnDefinition<TOutput, TSqlType extends AnySqlType, TStorageType extends PortableStorageType, TCastType extends PortableCastType, TOptions extends BuiltInColumnOptions> = ColumnDefinition<Simplify$1<{
+type BuiltInColumnDefinition<TOutput, TSqlType extends AnySqlType, TStorageType extends PortableStorageType, TCastType extends PortableCastType, TOptions extends BuiltInColumnOptions<TOutput>> = ColumnDefinition<Simplify$1<{
   readonly output: TOutput;
   readonly sqlType: TSqlType;
   readonly storage: PortableColumnStorage<TStorageType>;
 } & ColumnOptionConfig<TOptions>>> & {
   readonly castTarget: PortableCastTarget<TCastType>;
 };
-type ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends ColumnOptions, TSqlType extends AnySqlType = SqlUnknown> = ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
+type ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends ColumnOptions<TOutput, TInsert>, TSqlType extends AnySqlType = SqlUnknown> = ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
   readonly sqlType: TSqlType;
 } & ColumnOptionConfig<TOptions>>> & (TOptions extends {
   readonly castType: string;
@@ -1038,6 +1131,10 @@ type ColumnUpdateInput<T> = T extends {
 type ColumnHasDefault<T> = T extends {
   readonly hasDefault: infer THasDefault extends boolean;
 } ? THasDefault : false;
+/** Whether an omitted application insert can be supplied at runtime. */
+type ColumnHasRuntimeDefault<T> = T extends {
+  readonly hasRuntimeDefault: infer THasRuntimeDefault extends boolean;
+} ? THasRuntimeDefault : false;
 type ColumnIsGenerated<T> = T extends {
   readonly generated: infer TGenerated extends boolean;
 } ? TGenerated : false;
@@ -1076,7 +1173,7 @@ type AnyColumnDefinition = ColumnDefinition<any>;
 type NamedCastColumn<TDefinition extends AnyColumnDefinition> = TDefinition & {
   readonly castTarget: NamedCastTarget;
 };
-declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TStorage extends ColumnStorage = ColumnStorage, const TOptions extends Omit<ColumnOptions, "storage"> = Omit<ColumnOptions, "storage">>(options: TOptions & {
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TStorage extends ColumnStorage = ColumnStorage, const TOptions extends Omit<ColumnOptions<TOutput, TInsert>, "storage"> = Omit<ColumnOptions<TOutput, TInsert>, "storage">>(options: TOptions & {
   readonly storage: TStorage;
 }): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions & {
   readonly storage: TStorage;
@@ -1165,17 +1262,21 @@ declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert,
 declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown>(options?: FalseColumnOptions): ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
   readonly sqlType: TSqlType;
 }>>;
-declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TOptions extends ColumnOptions = {}>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
-declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends ColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
+declare function column<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, TSqlType extends AnySqlType = SqlUnknown, const TOptions extends ColumnOptions<TOutput, TInsert> = {}>(options?: TOptions): ColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType>;
+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 resultDecoder?: ResultDecoder;
 }): ResultValueMetadata | undefined;
-type NativeColumnOptions = Omit<ColumnOptions, "storage"> & {
+/** Apply a live column codec while preserving SQL NULL unchanged. */
+declare function encodeColumnParameter(definition: {
+  readonly parameterEncoder?: (value: any) => unknown;
+}, value: unknown): unknown;
+type NativeColumnOptions<TOutput, TInsert> = Omit<ColumnOptions<TOutput, TInsert>, "storage"> & {
   readonly storage?: never;
 };
-type NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends NativeColumnOptions, TSqlType extends AnySqlType, TDialect extends string, TDeclaration extends string> = ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
+type NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends NativeColumnOptions<TOutput, TInsert>, TSqlType extends AnySqlType, TDialect extends string, TDeclaration extends string> = ColumnDefinition<Simplify$1<ColumnValueConfig<TOutput, TInsert, TUpdate> & {
   readonly sqlType: TSqlType;
 } & ColumnOptionConfig<TOptions> & {
   readonly storage: NativeColumnStorage<TDialect, TDeclaration>;
@@ -1185,22 +1286,22 @@ type NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions extends NativeC
   readonly castTarget: NamedCastTarget;
 } : unknown);
 /** Create a column whose physical declaration belongs to one SQL dialect. */
-declare function nativeColumn<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown, const TDialect extends string = string, const TDeclaration extends string = string>(storage: NativeColumnStorage<TDialect, TDeclaration>, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
+declare function nativeColumn<TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions<TOutput, TInsert> = {}, TSqlType extends AnySqlType = SqlUnknown, const TDialect extends string = string, const TDeclaration extends string = string>(storage: NativeColumnStorage<TDialect, TDeclaration>, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
 /** Create a dialect-native column from an adapter name and exact declaration. */
-declare function nativeColumn<const TDialect extends string, const TDeclaration extends string, TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions = {}, TSqlType extends AnySqlType = SqlUnknown>(dialect: TDialect, type: TDeclaration, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
+declare function nativeColumn<const TDialect extends string, const TDeclaration extends string, TOutput = unknown, TInsert = TOutput, TUpdate = TInsert, const TOptions extends NativeColumnOptions<TOutput, TInsert> = {}, TSqlType extends AnySqlType = SqlUnknown>(dialect: TDialect, type: TDeclaration, options?: TOptions): NativeColumnFromOptions<TOutput, TInsert, TUpdate, TOptions, TSqlType, TDialect, TDeclaration>;
 declare function nullable<TConfig extends ColumnDefinitionConfig>(definition: ColumnDefinition<TConfig>): ColumnDefinition<Simplify$1<Omit<TConfig, "nullable"> & {
   readonly nullable: true;
 }>>;
-declare function integer<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlInteger, "integer", "integer", TOptions>;
-declare function numeric<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlDecimal, "numeric", "decimal", TOptions>;
-declare function text<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlText, "text", "text", TOptions>;
-declare function boolean<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<boolean, SqlBoolean, "boolean", "boolean", TOptions>;
-declare function date<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlDate, "date", "date", TOptions>;
-declare function timestamp<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlTimestamp, "timestamp", "timestamp", TOptions>;
-declare function uuid<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlUuid, "uuid", "uuid", TOptions>;
-declare function json<TOutput = unknown, const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<TOutput, SqlJson<TOutput>, "json", "json", TOptions>;
-declare function bigint<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<bigint, SqlBigInt, "bigint", "bigint", TOptions>;
-declare function binary<const TOptions extends BuiltInColumnOptions = {}>(options?: TOptions): BuiltInColumnDefinition<Uint8Array, SqlBinary, "binary", "binary", TOptions>;
+declare function integer<const TOptions extends BuiltInColumnOptions<number> = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlInteger, "integer", "integer", TOptions>;
+declare function numeric<const TOptions extends BuiltInColumnOptions<number> = {}>(options?: TOptions): BuiltInColumnDefinition<number, SqlDecimal, "numeric", "decimal", TOptions>;
+declare function text<const TOptions extends BuiltInColumnOptions<string> = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlText, "text", "text", TOptions>;
+declare function boolean<const TOptions extends BuiltInColumnOptions<boolean> = {}>(options?: TOptions): BuiltInColumnDefinition<boolean, SqlBoolean, "boolean", "boolean", TOptions>;
+declare function date<const TOptions extends BuiltInColumnOptions<Date> = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlDate, "date", "date", TOptions>;
+declare function timestamp<const TOptions extends BuiltInColumnOptions<Date> = {}>(options?: TOptions): BuiltInColumnDefinition<Date, SqlTimestamp, "timestamp", "timestamp", TOptions>;
+declare function uuid<const TOptions extends BuiltInColumnOptions<string> = {}>(options?: TOptions): BuiltInColumnDefinition<string, SqlUuid, "uuid", "uuid", TOptions>;
+declare function json<TOutput = unknown, const TOptions extends BuiltInColumnOptions<TOutput> = {}>(options?: TOptions): BuiltInColumnDefinition<TOutput, SqlJson<TOutput>, "json", "json", TOptions>;
+declare function bigint<const TOptions extends BuiltInColumnOptions<bigint> = {}>(options?: TOptions): BuiltInColumnDefinition<bigint, SqlBigInt, "bigint", "bigint", TOptions>;
+declare function binary<const TOptions extends BuiltInColumnOptions<Uint8Array> = {}>(options?: TOptions): BuiltInColumnDefinition<Uint8Array, SqlBinary, "binary", "binary", TOptions>;
 //#endregion
 //#region src/expressions/cast.d.ts
 type CastDefinition = ColumnDefinition<any> & {
@@ -3493,8 +3594,12 @@ type InsertRow<TTable extends AnyTable> = TableInsertInput<TTable["definitions"]
 type InvalidInsertRow<TTable extends AnyTable, TRow> = TRow extends InsertRow<TTable> ? Exclude<keyof TRow, keyof InsertRow<TTable>> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.values.columns", "Use only columns declared by the insert table.", Exclude<keyof TRow, keyof InsertRow<TTable>>> : QueryTypeValidation<"invalid-insert", "insert.values.row", "Provide values matching the insert table columns.", TRow>;
 type ValidInsertSource<TTable extends AnyTable, TSource extends InsertSource> = TSource extends ValuesSource<infer TRows> ? TRows[number] extends (infer TRow) ? InvalidInsertRow<TTable, TRow> : never : TSource extends DefaultValuesSource ? Exclude<keyof TTable["definitions"], { [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? K : TTable["definitions"][K] extends {
   hasDefault: true;
+} | {
+  hasRuntimeDefault: true;
 } ? K : never; }[keyof TTable["definitions"]]> extends never ? unknown : QueryTypeValidation<"invalid-insert", "insert.default-values", "Provide values for required columns or define defaults for them.", Exclude<keyof TTable["definitions"], { [K in keyof TTable["definitions"]]-?: ColumnIsGenerated<TTable["definitions"][K]> extends true ? K : TTable["definitions"][K] extends {
   hasDefault: true;
+} | {
+  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>, ...clauses: TClauses & MutationScopeValidation<TTable, TClauses>): MutationQuery<{
   readonly row: MutationRow<TClauses>;
@@ -3556,7 +3661,7 @@ type AnyTable = Source<any> & {
 type TableRow<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions]: ColumnOutput<TDefinitions[K]>; };
 /** SQL semantic domains derived from a table's column definitions. */
 type TableSqlTypes<TDefinitions extends TableDefinitions> = { readonly [K in keyof TDefinitions]: ColumnSqlType<TDefinitions[K]>; };
-type RequiredInsertKeys<TDefinitions extends TableDefinitions> = { [K in keyof TDefinitions]-?: ColumnHasDefault<TDefinitions[K]> extends true ? never : ColumnIsGenerated<TDefinitions[K]> extends true ? never : K; }[keyof TDefinitions];
+type RequiredInsertKeys<TDefinitions extends TableDefinitions> = { [K in keyof TDefinitions]-?: ColumnHasDefault<TDefinitions[K]> extends true ? never : ColumnHasRuntimeDefault<TDefinitions[K]> extends true ? never : ColumnIsGenerated<TDefinitions[K]> extends true ? never : K; }[keyof TDefinitions];
 type OptionalInsertKeys<TDefinitions extends TableDefinitions> = Exclude<keyof TDefinitions, RequiredInsertKeys<TDefinitions>>;
 type TableInsertInput<TDefinitions extends TableDefinitions> = { -readonly [K in RequiredInsertKeys<TDefinitions>]: ColumnInsertInput<TDefinitions[K]>; } & { -readonly [K in OptionalInsertKeys<TDefinitions>]?: ColumnInsertInput<TDefinitions[K]>; };
 type TableUpdateInput<TDefinitions extends TableDefinitions> = { -readonly [K in keyof TDefinitions as ColumnIsGenerated<TDefinitions[K]> extends true ? never : K]?: ColumnUpdateInput<TDefinitions[K]>; };
@@ -4144,4 +4249,4 @@ type SchemaSnapshotInput = SchemaSnapshot | Readonly<Record<string, unknown>>;
 /** Expose the schema generic in tooling declarations without widening APIs. */
 type AnySchema = Schema<any>;
 //#endregion
-export { PaginationKind as $, SqlTag as $a, RenderCapabilityValidation as $c, SourceIndexesRecord as $i, InheritedMetadata as $l, WithClause as $n, ColumnStorageOf as $o, generatedTableName as $r, canonicalLiteral as $s, nullsLast as $t, SnapshotStorage as A, jsonBoolean as Aa, ExplainableQueryAdapter as Ac, catalogCheck as Ai, ResultField as Al, MutationReturningClause as An, value as Ao, SchemaExpressionErrorCode as Ar, timestamp as As, SourceSqlTypeMap as At, SqlBoolean as Au, CastTarget as B, concat as Ba, QubuTransactionalClient as Bc, AliasedSource as Bi, CapabilityMetadataOf as Bl, select as Bn, ColumnIdentityOf as Bo, renderSchemaSql as Br, ExternalDefaultDescriptor as Bs, TableDefinitions as Bt, SqlSemanticType as Bu, SnapshotIndexTerm as C, SelectClause as Ca, ExplainMutationOptions as Cc, SourceConstraintsRecord as Ci, markExpressionCategory as Cl, update as Cn, isTrue as Co, SelectionSqlTypes as Cr, json as Cs, SourceColumns as Ct, fragment as Cu, SnapshotLiteral as D, multiply as Da, ExplainReadOptions as Dc, UniqueConstraint as Di, ResultDecoder as Dl, MutationQuery as Dn, SqlCapabilityValidation as Do, createSchemaDialect as Dr, numeric as Ds, SourceKind as Dt, AnySqlType as Du, SnapshotKeyConstraint as E, modulo as Ea, ExplainPlanRow as Ec, TableLike as Ei, ResultDecodeContext as El, MutationKind as En, OperandSqlType as Eo, SchemaDialectHooks as Er, nullable as Es, SourceIdentity as Et, sequence as Eu, neutralSnapshotDialect as F, denseRank as Fa, QubuStreamingClient as Fc, references as Fi, timestampResultDecoder as Fl, ReturningClause as Fn, ColumnDefinition as Fo, UnsafeSchemaSqlExpression as Fr, ColumnDefault as Fs, exposeColumns as Ft, SqlInteger as Fu, DialectJson as G, typedCall as Ga, StreamingTransactionalQueryAdapter as Gc, alias as Gi, Fragment as Gl, MissingScope as Gn, ColumnOptions as Go, SchemaNamingPolicy as Gr, IdentityDescriptor as Gs, TableRow as Gt, SqlUnknown as Gu, DialectCapability as H, upper as Ha, QueryExecutor as Hc, LateralSource as Hi, CardinalityOf as Hl, AvailableScope as Hn, ColumnIsGenerated as Ho, unsafeSchemaSql as Hr, GeneratedColumnDescriptor as Hs, TableInsertInput as Ht, SqlTextLike as Hu, schemaSnapshotDialectVersion as I, over as Ia, QubuStreamingExplainableClient as Ic, unique as Ii, AggregateDependenciesOf as Il, ReturningRow as In, ColumnDefinitionConfig as Io, defineSchemaExpression as Ir, ColumnDefaultInput as Is, sourceIdentity as It, SqlJson as Iu, DialectRowLocking as J, countDistinct as Ja, execute as Jc, IndexOptions as Ji, GroupingKeysOf as Jl, ScopeValidation as Jn, ColumnStorage as Jo, SchemaTableNames as Jr, LiteralDefaultDescriptor as Js, table as Jt, DialectOptions as K, avg as Ka, TransactionOptions as Kc, lateral as Ki, FragmentMeta as Kl, RequiredOuterScope as Kn, ColumnOutput as Ko, SchemaOptions as Kr, IdentityDialectExtension as Ks, TableSqlTypes as Kt, SqlUuid as Ku, schemaSnapshotFormat as L, rank as La, QubuStreamingTransaction as Lc, uniqueConstraint as Li, AggregateMeta as Ll, ReturningSqlTypes as Ln, ColumnFromOptions as Lo, isUnsafeSchemaSql as Lr, DefaultDescriptor as Ls, AnyTable as Lt, SqlNumericLike as Lu, SnapshotTable as M, jsonNumber as Ma, QubuExplainableClient as Mc, check as Mi, booleanResultDecoder as Ml, MutationScopeValidation as Mn, cast as Mo, SchemaExpressionMode as Mr, CanonicalLiteral as Ms, UnknownSourceSqlTypes as Mt, SqlDecimal as Mu, SnapshotUniqueConstraint as N, jsonPath as Na, QubuExplainableStreamingTransactionalClient as Nc, foreignKey as Ni, dateResultDecoder as Nl, MutationSqlTypes as Nn, typedCast as No, SchemaRenderContext as Nr, ColumnBehaviorError as Ns, createSource as Nt, SqlEqualityComparable as Nu, SnapshotNamingPolicy as O, subtract as Oa, ExplainRequest as Oc, UniqueConstraintOptions as Oi, ResultDecoders as Ol, MutationQueryConfig as On, asValue as Oo, RenderedSchemaExpression as Or, portableStorage as Os, SourceProvision as Ot, SqlBigInt as Ou, SnapshotValidationContext as P, jsonText as Pa, QubuExplainableTransactionalClient as Pc, primaryKey as Pi, jsonTextResultDecoder as Pl, allowAll as Pn, ColumnDefaultOf as Po, SchemaRenderOptions as Pr, ColumnBehaviorErrorCode as Ps, customSource as Pt, SqlEqualityCompatible as Pu, NamedCastTarget as Q, SqlFragment as Qa, stream as Qc, SourceIndex as Qi, HasWindow as Ql, RecursiveCteSource as Qn, ColumnStorageKindOf as Qo, defaultSchemaNamingPolicy as Qr, SqliteIdentityExtension as Qs, nullsFirst as Qt, schemaSnapshotNamingPolicyVersion as R, rowNumber as Ra, QubuStreamingTransactionalClient as Rc, validateConstraintDialect as Ri, AnyFragment as Rl, returning as Rn, ColumnGeneratedOf as Ro, normalizeSchemaSql as Rr, ExpressionDefaultDescriptor as Rs, Table as Rt, SqlOrderCompatible as Ru, SnapshotIndex as S, ClausePlacement as Sa, ExecutionResult as Sc, SourceConstraint as Si, makeExpression as Sl, UpdateAssignments as Sn, isNull as So, SelectionOutput as Sr, integer as Ss, Source as St, WindowMeta as Su, SnapshotJsonValue as T, divide as Ta, ExplainOptionsFor as Tc, SqliteConstraintExtension as Ti, DecodableResultType as Tl, MutationClause as Tn, OperandNullability as To, SchemaDialect as Tr, nativeStorage as Ts, SourceConstraints as Tt, parenthesize as Tu, DialectCastTypes as U, call as Ua, StreamableQuery as Uc, QueryAliasIdentity as Ui, DependenciesOf as Ul, ClauseScope as Un, ColumnIsNullable as Uo, Schema as Ur, GeneratedColumnMode as Us, TableMetadataCallback as Ut, SqlTimestamp as Uu, Dialect as V, lower as Va, QueryAdapter as Vc, LateralIdentity as Vi, CardinalityMeta as Vl, AvailableOuterScope as Vn, ColumnInsertInput as Vo, schemaExpression as Vr, ExternalGeneratedColumnDescriptor as Vs, TableIdentity as Vt, SqlText as Vu, DialectExplain as W, schemaCall as Wa, StreamingQueryAdapter as Wc, QuerySource as Wi, ExpressionMeta as Wl, GroupingValidation as Wn, ColumnOnUpdateOf as Wo, SchemaDiagnostic as Wr, GeneratedDescriptor as Ws, TableOptions as Wt, SqlTypeSatisfies as Wu, ExplainRenderOptions as X, min as Xa, explain as Xc, MysqlIndexExtension as Xi, HasAggregate as Xl, SelectQuery as Xn, ColumnStorageDescriptor as Xo, SchemaTableRegistry as Xr, ResolvedColumnBehavior as Xs, asc as Xt, ExplainFormat as Y, max as Ya, executeRows as Yc, IndexTerm as Yi, GroupingMeta as Yl, SelectCardinality as Yn, ColumnStorageDeclarationOf as Yo, SchemaTableRecord as Yr, MysqlIdentityExtension as Ys, OrderTerm as Yt, JsonScalarKind as Z, sum as Za, qubu as Zc, PostgresIndexExtension as Zi, HasSubquery as Zl, CteSource as Zn, ColumnStorageDialectOf as Zo, SchemaValidationError as Zr, SchemaLiteralValue as Zs, desc as Zt, SnapshotExpressionContext as _, fetchNext as _a, materializeSchemaObjectRecord as _c, KeyConstraint as _i, ExpressionSqlType as _l, doNothing as _n, notLike as _o, FromScope as _r, binary as _s, AnySource as _t, RequiresSourceMeta as _u, SnapshotBigInt as a, and as aa, SchemaDialectExtension as ac, CheckConstraint as ai, QueryValidationErrorCode as al, InsertSource as an, notExists as ao, except as ar, NativeStorage as as, SchemaLiteralRenderer as at, OutputOf as au, SnapshotGeneratedColumn as b, distinct as ba, ExecutionOptions as bc, PostgresConstraintExtension as bi, SchemaExpressionBrand as bl, onConflict as bn, notIn as bo, Selection as br, columnResultValue as bs, ProvidedSourceIdentity as bt, SubqueryMeta as bu, SnapshotConstraint as c, Omit$1 as ca, SchemaMetadataValidationError as cc, ConstraintOptions as ci, ColumnReference as cl, insertInto as cn, eq as co, unionAll as cr, PortableStorage as cs, resolveCastTarget as ct, ProvidesSourceMeta as cu, SnapshotDefault as d, omit as da, assertSchemaDialectSupport as dc, FieldLikeOptions as di, AnySchemaExpression as dl, ConflictAction as dn, isDistinctFrom as do, innerJoin as dr, StorageDeclarationOf as ds, QueryConfig as dt, RenderFunction as du, SqliteIndexExtension as ea, externalDefault as ec, schema as ei, RenderOptions as el, order as en, TypedSqlTag as eo, cte as er, ColumnStorageType as es, PaginationPart as et, InheritedMetadataOf as eu, SnapshotDiagnostic as f, where as fa, dialectMismatchDiagnostic as fc, ForeignKeyConstraint as fi, Expression as fl, ConflictTarget as fn, isNotDistinctFrom as fo, leftJoin as fr, StorageDescriptor as fs, QueryKind as ft, RequiresCapabilityMeta as fu, SnapshotExpression as g, fetchFirst as ga, materializeSchemaObjectIdentity as gc, ForeignKeyTargetInput as gi, ExpressionRequires as gl, OnConflictClause as gn, ne as go, FromClause as gr, bigint as gs, Row as gt, RequiresOuterSourceMeta as gu, SnapshotDialectExtension as h, rowLock as ha, isValidSchemaObjectName as hc, ForeignKeyTarget as hi, ExpressionOutput as hl, ExcludedSource as hn, lte as ho, groupBy as hr, StorageTypeOf as hs, QueryWithRow as ht, RequiresOuterOf as hu, SchemaSnapshotInput as i, DeclaredColumnNullability as ia, resolveColumnBehavior as ic, CatalogCheckSql as ii, QueryValidationError as il, InsertSelectSource as in, inQuery as io, SetQuery as ir, NativeColumnStorage as is, RowLockWaitPolicy as it, NullableSourcesOf as iu, SnapshotStorageContext as j, jsonExists as ja, QubuClient as jc, catalogForeignKey as ji, ResultShape as jl, MutationRow as jn, mapResult as jo, SchemaExpressionInput as jr, uuid as js, SourceSqlTypes as jt, SqlDate as ju, SnapshotSpecialNumber as k, JsonPath as ka, ExplainResult as kc, UniqueNullSemantics as ki, ResultDecodingError as kl, MutationReturning as kn, typedValue as ko, SchemaExpressionError as kr, text as ks, SourceRow as kt, SqlBinary as ku, SnapshotCreateResult as l, OmittableSelectClause as la, SchemaObjectIdentity as lc, ConstraintTiming as li, expressionFragment as ll, insertSelect as ln, gt as lo, crossJoin as lr, PortableStorageDescriptor as ls, AnyQuery as lt, QueryCardinality as lu, SnapshotDialect as m, RowLockOptions as ma, generatedSchemaObjectName as mc, ForeignKeyOptions as mi, ExpressionNullability as ml, DoUpdateAction as mn, lt as mo, rightJoin as mr, StorageOf as ms, QuerySqlTypeMap as mt, RequiresOuterMetadataOf as mu, SchemaSnapshot as n, index as na, generatedColumn as nc, AnyKeyColumn as ni, render as nl, deleteFrom as nn, caseWhen as no, withCte as nr, ColumnUpdateInput as ns, PortableCastType as nt, NullabilityOf as nu, SnapshotCheckConstraint as o, not as oa, SchemaDialectName as oc, CheckConstraintOptions as oi, QueryValidationIssue as ol, ValuesSource as on, scalar as oo, intersect as or, NativeStorageDescriptor as os, assertDialectCapability as ot, ProvidesOuterOf as ou, SnapshotDiagnosticCode as p, RowLockClause as pa, freezeSchemaMetadata as pc, ForeignKeyMatch as pi, ExpressionKind as pl, DoNothingAction as pn, like as po, naturalJoin as pr, StorageDialectOf as ps, QueryRow as pt, RequiresOf as pu, DialectPagination as q, count as qa, TransactionalQueryAdapter as qc, IndexDialectExtension as qi, GroupingDependenciesOf as ql, RequiredScope as qn, ColumnSqlType as qo, SchemaTableEntry as qr, IdentityGeneration as qs, TableUpdateInput as qt, SchemaSnapshotAdapter as r, validateIndexDialect as ra, identityColumn as rc, CatalogCheckExpression as ri, QueryTypeValidation as rl, DefaultValuesSource as rn, exists as ro, SetOperator as rr, DialectNativeStorage as rs, RowLockMode as rt, NullableSourceMeta as ru, SnapshotColumn as s, or as sa, SchemaMetadataDiagnostic as sc, ConstraintDialectExtension as si, ColumnDependency as sl, defaultValues as sn, ComparisonValidation as so, union as sr, PortableColumnStorage as ss, createDialect as st, ProvidesOuterSourceMeta as su, AnySchema as t, TableIndex as ta, externalGeneratedColumn as tc, schemaNamingPolicyVersion as ti, RenderedQuery as tl, orderBy as tn, sql as to, recursiveCte as tr, ColumnStorageTypeOf as ts, PortableCastTarget as tt, MetadataOf as tu, SnapshotDecodeResult as u, SelectPart as ua, SchemaObjectNameOptions as uc, FieldLike as ui, AnyExpression as ul, values as un, gte as uo, fullJoin as ur, PortableStorageType as us, Query as ut, RenderContext as uu, SnapshotExtensionContext as v, offset as va, AdapterExecutionResult as vc, KeyConstraintOptions as vi, ExpressionWithOutput as vl, doUpdate as vn, between as vo, FromSource as vr, boolean as vs, CustomSource as vt, ResultMeta as vu, SnapshotIndexTermExpression as w, add as wa, ExplainOptions as wc, SourceLike as wi, withDialectCapability as wl, AllowAllClause as wn, Operand as wo, all as wr, nativeColumn as ws, SourceConfig as wt, isFragment as wu, SnapshotIdentity as x, AnySelectClause as xa, ExecutionRequest as xc, ReferentialAction as xi, isExpression as xl, UpdateAssignmentValue as xn, isNotNull as xo, SelectionObject as xr, date as xs, ProvidedSourceRow as xt, VisibleDependenciesOf as xu, SnapshotForeignKey as y, having as ya, DriverValueEncoder as yc, MysqlConstraintExtension as yi, SchemaExpression as yl, excluded as yn, inList as yo, from as yr, column as ys, CustomSourceOptions as yt, SqlTypeOf as yu, schemaSnapshotVersion as z, coalesce as za, QubuTransaction as zc, AliasIdentity as zi, CapabilitiesOf as zl, correlate as zn, ColumnHasDefault as zo, renderSchemaExpression as zr, ExpressionGeneratedColumnDescriptor as zs, TableColumns as zt, SqlOrderable as zu };
+export { PaginationKind as $, SqlTag as $a, QubuStreamingTransaction as $c, SourceIndexesRecord as $i, AggregateMeta as $l, WithClause as $n, ColumnStorageDialectOf as $o, generatedTableName as $r, ResolvedColumnBehavior as $s, nullsLast as $t, SqlNumericLike as $u, SnapshotStorage as A, jsonBoolean as Aa, ExplainReadOptions as Ac, catalogCheck as Ai, ExpressionNullability as Al, MutationReturningClause as An, value as Ao, SchemaExpressionErrorCode as Ar, numeric as As, SourceSqlTypeMap as At, RequiresOuterMetadataOf as Au, CastTarget as B, concat as Ba, HookQueryOperation as Bc, AliasedSource as Bi, withDialectCapability as Bl, select as Bn, ColumnHasDefault as Bo, renderSchemaSql as Br, DefaultDescriptor as Bs, TableDefinitions as Bt, isFragment as Bu, SnapshotIndexTerm as C, SelectClause as Ca, ExecutionOptions as Cc, SourceConstraintsRecord as Ci, ColumnDependency as Cl, update as Cn, isTrue as Co, SelectionSqlTypes as Cr, date as Cs, SourceColumns as Ct, ProvidesOuterSourceMeta as Cu, SnapshotLiteral as D, multiply as Da, ExplainOptions as Dc, UniqueConstraint as Di, AnySchemaExpression as Dl, MutationQuery as Dn, SqlCapabilityValidation as Do, createSchemaDialect as Dr, nativeColumn as Ds, SourceKind as Dt, RenderFunction as Du, SnapshotKeyConstraint as E, modulo as Ea, ExplainMutationOptions as Ec, TableLike as Ei, AnyExpression as El, MutationKind as En, OperandSqlType as Eo, SchemaDialectHooks as Er, json as Es, SourceIdentity as Et, RenderContext as Eu, neutralSnapshotDialect as F, denseRank as Fa, HookMetadata as Fc, references as Fi, SchemaExpression as Fl, ReturningClause as Fn, ColumnDefaultOf as Fo, UnsafeSchemaSqlExpression as Fr, CanonicalLiteral as Fs, exposeColumns as Ft, SqlTypeOf as Fu, DialectJson as G, typedCall as Ga, QubuClient as Gc, alias as Gi, ResultDecodingError as Gl, MissingScope as Gn, ColumnIsNullable as Go, SchemaNamingPolicy as Gr, GeneratedColumnDescriptor as Gs, TableRow as Gt, SqlBinary as Gu, DialectCapability as H, upper as Ha, HookSuccessOutcome as Hc, LateralSource as Hi, ResultDecodeContext as Hl, AvailableScope as Hn, ColumnIdentityOf as Ho, unsafeSchemaSql as Hr, ExpressionGeneratedColumnDescriptor as Hs, TableInsertInput as Ht, sequence as Hu, schemaSnapshotDialectVersion as I, over as Ia, HookMetadataValue as Ic, unique as Ii, SchemaExpressionBrand as Il, ReturningRow as In, ColumnDefinition as Io, defineSchemaExpression as Ir, ColumnBehaviorError as Is, sourceIdentity as It, SubqueryMeta as Iu, DialectRowLocking as J, countDistinct as Ja, QubuExplainableTransactionalClient as Jc, IndexOptions as Ji, booleanResultDecoder as Jl, ScopeValidation as Jn, ColumnOutput as Jo, SchemaTableNames as Jr, IdentityDescriptor as Js, table as Jt, SqlDecimal as Ju, DialectOptions as K, avg as Ka, QubuExplainableClient as Kc, lateral as Ki, ResultField as Kl, RequiredOuterScope as Kn, ColumnOnUpdateOf as Ko, SchemaOptions as Kr, GeneratedColumnMode as Ks, TableSqlTypes as Kt, SqlBoolean as Ku, schemaSnapshotFormat as L, rank as La, HookOperation as Lc, uniqueConstraint as Li, isExpression as Ll, ReturningSqlTypes as Ln, ColumnDefinitionConfig as Lo, isUnsafeSchemaSql as Lr, ColumnBehaviorErrorCode as Ls, AnyTable as Lt, VisibleDependenciesOf as Lu, SnapshotTable as M, jsonNumber as Ma, ExplainResult as Mc, check as Mi, ExpressionRequires as Ml, MutationScopeValidation as Mn, cast as Mo, SchemaExpressionMode as Mr, text as Ms, UnknownSourceSqlTypes as Mt, RequiresOuterSourceMeta as Mu, SnapshotUniqueConstraint as N, jsonPath as Na, ExplainableQueryAdapter as Nc, foreignKey as Ni, ExpressionSqlType as Nl, MutationSqlTypes as Nn, typedCast as No, SchemaRenderContext as Nr, timestamp as Ns, createSource as Nt, RequiresSourceMeta as Nu, SnapshotNamingPolicy as O, subtract as Oa, ExplainOptionsFor as Oc, UniqueConstraintOptions as Oi, Expression as Ol, MutationQueryConfig as On, asValue as Oo, RenderedSchemaExpression as Or, nativeStorage as Os, SourceProvision as Ot, RequiresCapabilityMeta as Ou, SnapshotValidationContext as P, jsonText as Pa, HookErrorOutcome as Pc, primaryKey as Pi, ExpressionWithOutput as Pl, allowAll as Pn, ColumnCodec as Po, SchemaRenderOptions as Pr, uuid as Ps, customSource as Pt, ResultMeta as Pu, NamedCastTarget as Q, SqlFragment as Qa, QubuStreamingExplainableClient as Qc, SourceIndex as Qi, AggregateDependenciesOf as Ql, RecursiveCteSource as Qn, ColumnStorageDescriptor as Qo, defaultSchemaNamingPolicy as Qr, MysqlIdentityExtension as Qs, nullsFirst as Qt, SqlJson as Qu, schemaSnapshotNamingPolicyVersion as R, rowNumber as Ra, HookOperationKind as Rc, validateConstraintDialect as Ri, makeExpression as Rl, returning as Rn, ColumnFromOptions as Ro, normalizeSchemaSql as Rr, ColumnDefault as Rs, Table as Rt, WindowMeta as Ru, SnapshotIndex as S, ClausePlacement as Sa, DriverValueEncoder as Sc, SourceConstraint as Si, QueryValidationIssue as Sl, UpdateAssignments as Sn, isNull as So, SelectionOutput as Sr, columnResultValue as Ss, Source as St, ProvidesOuterOf as Su, SnapshotJsonValue as T, divide as Ta, ExecutionResult as Tc, SqliteConstraintExtension as Ti, expressionFragment as Tl, MutationClause as Tn, OperandNullability as To, SchemaDialect as Tr, integer as Ts, SourceConstraints as Tt, QueryCardinality as Tu, DialectCastTypes as U, call as Ua, HookTransactionOperation as Uc, QueryAliasIdentity as Ui, ResultDecoder as Ul, ClauseScope as Un, ColumnInsertInput as Uo, Schema as Ur, ExternalDefaultDescriptor as Us, TableMetadataCallback as Ut, AnySqlType as Uu, Dialect as V, lower as Va, HookStreamEnd as Vc, LateralIdentity as Vi, DecodableResultType as Vl, AvailableOuterScope as Vn, ColumnHasRuntimeDefault as Vo, schemaExpression as Vr, ExpressionDefaultDescriptor as Vs, TableIdentity as Vt, parenthesize as Vu, DialectExplain as W, schemaCall as Wa, OperationEndHook as Wc, QuerySource as Wi, ResultDecoders as Wl, GroupingValidation as Wn, ColumnIsGenerated as Wo, SchemaDiagnostic as Wr, ExternalGeneratedColumnDescriptor as Ws, TableOptions as Wt, SqlBigInt as Wu, ExplainRenderOptions as X, min as Xa, QubuOptions as Xc, MysqlIndexExtension as Xi, jsonTextResultDecoder as Xl, SelectQuery as Xn, ColumnStorage as Xo, SchemaTableRegistry as Xr, IdentityGeneration as Xs, asc as Xt, SqlEqualityCompatible as Xu, ExplainFormat as Y, max as Ya, QubuHooks as Yc, IndexTerm as Yi, dateResultDecoder as Yl, SelectCardinality as Yn, ColumnSqlType as Yo, SchemaTableRecord as Yr, IdentityDialectExtension as Ys, OrderTerm as Yt, SqlEqualityComparable as Yu, JsonScalarKind as Z, sum as Za, QubuStreamingClient as Zc, PostgresIndexExtension as Zi, timestampResultDecoder as Zl, CteSource as Zn, ColumnStorageDeclarationOf as Zo, SchemaValidationError as Zr, LiteralDefaultDescriptor as Zs, desc as Zt, SqlInteger as Zu, SnapshotExpressionContext as _, fetchNext as _a, generatedSchemaObjectName as _c, KeyConstraint as _i, RenderedQuery as _l, doNothing as _n, notLike as _o, FromScope as _r, StorageTypeOf as _s, AnySource as _t, MetadataOf as _u, SnapshotBigInt as a, and as aa, generatedColumn as ac, SqlTimestamp as ad, CheckConstraint as ai, StreamableQuery as al, InsertSource as an, notExists as ao, except as ar, DialectNativeStorage as as, SchemaLiteralRenderer as at, DependenciesOf as au, SnapshotGeneratedColumn as b, distinct as ba, materializeSchemaObjectRecord as bc, PostgresConstraintExtension as bi, QueryValidationError as bl, onConflict as bn, notIn as bo, Selection as br, boolean as bs, ProvidedSourceIdentity as bt, NullableSourcesOf as bu, SnapshotConstraint as c, Omit$1 as ca, SchemaDialectExtension as cc, SqlUuid as cd, ConstraintOptions as ci, TransactionOptions as cl, insertInto as cn, eq as co, unionAll as cr, NativeStorageDescriptor as cs, resolveCastTarget as ct, FragmentMeta as cu, SnapshotDefault as d, omit as da, SchemaMetadataValidationError as dc, FieldLikeOptions as di, executeRows as dl, ConflictAction as dn, isDistinctFrom as do, innerJoin as dr, PortableStorageDescriptor as ds, QueryConfig as dt, GroupingMeta as du, SqliteIndexExtension as ea, SchemaLiteralValue as ec, SqlOrderCompatible as ed, schema as ei, QubuStreamingTransactionalClient as el, order as en, TypedSqlTag as eo, cte as er, ColumnStorageKindOf as es, PaginationPart as et, AnyFragment as eu, SnapshotDiagnostic as f, where as fa, SchemaObjectIdentity as fc, ForeignKeyConstraint as fi, explain as fl, ConflictTarget as fn, isNotDistinctFrom as fo, leftJoin as fr, PortableStorageType as fs, QueryKind as ft, HasAggregate as fu, SnapshotExpression as g, fetchFirst as ga, freezeSchemaMetadata as gc, ForeignKeyTargetInput as gi, RenderOptions as gl, OnConflictClause as gn, ne as go, FromClause as gr, StorageOf as gs, Row as gt, InheritedMetadataOf as gu, SnapshotDialectExtension as h, rowLock as ha, dialectMismatchDiagnostic as hc, ForeignKeyTarget as hi, RenderCapabilityValidation as hl, ExcludedSource as hn, lte as ho, groupBy as hr, StorageDialectOf as hs, QueryWithRow as ht, InheritedMetadata as hu, SchemaSnapshotInput as i, DeclaredColumnNullability as ia, externalGeneratedColumn as ic, SqlTextLike as id, CatalogCheckSql as ii, QueryExecutor as il, InsertSelectSource as in, inQuery as io, SetQuery as ir, ColumnUpdateInput as is, RowLockWaitPolicy as it, CardinalityOf as iu, SnapshotStorageContext as j, jsonExists as ja, ExplainRequest as jc, catalogForeignKey as ji, ExpressionOutput as jl, MutationRow as jn, mapResult as jo, SchemaExpressionInput as jr, portableStorage as js, SourceSqlTypes as jt, RequiresOuterOf as ju, SnapshotSpecialNumber as k, JsonPath as ka, ExplainPlanRow as kc, UniqueNullSemantics as ki, ExpressionKind as kl, MutationReturning as kn, typedValue as ko, SchemaExpressionError as kr, nullable as ks, SourceRow as kt, RequiresOf as ku, SnapshotCreateResult as l, OmittableSelectClause as la, SchemaDialectName as lc, ConstraintTiming as li, TransactionalQueryAdapter as ll, insertSelect as ln, gt as lo, crossJoin as lr, PortableColumnStorage as ls, AnyQuery as lt, GroupingDependenciesOf as lu, SnapshotDialect as m, RowLockOptions as ma, assertSchemaDialectSupport as mc, ForeignKeyOptions as mi, stream as ml, DoUpdateAction as mn, lt as mo, rightJoin as mr, StorageDescriptor as ms, QuerySqlTypeMap as mt, HasWindow as mu, SchemaSnapshot as n, index as na, canonicalLiteral as nc, SqlSemanticType as nd, AnyKeyColumn as ni, QubuTransactionalClient as nl, deleteFrom as nn, caseWhen as no, withCte as nr, ColumnStorageType as ns, PortableCastType as nt, CapabilityMetadataOf as nu, SnapshotCheckConstraint as o, not as oa, identityColumn as oc, SqlTypeSatisfies as od, CheckConstraintOptions as oi, StreamingQueryAdapter as ol, ValuesSource as on, scalar as oo, intersect as or, NativeColumnStorage as os, assertDialectCapability as ot, ExpressionMeta as ou, SnapshotDiagnosticCode as p, RowLockClause as pa, SchemaObjectNameOptions as pc, ForeignKeyMatch as pi, qubu as pl, DoNothingAction as pn, like as po, naturalJoin as pr, StorageDeclarationOf as ps, QueryRow as pt, HasSubquery as pu, DialectPagination 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, TableUpdateInput as qt, SqlDate as qu, SchemaSnapshotAdapter as r, validateIndexDialect as ra, externalDefault as rc, SqlText as rd, CatalogCheckExpression as ri, QueryAdapter as rl, DefaultValuesSource as rn, exists as ro, SetOperator as rr, ColumnStorageTypeOf as rs, RowLockMode as rt, CardinalityMeta as ru, SnapshotColumn as s, or as sa, resolveColumnBehavior as sc, SqlUnknown as sd, ConstraintDialectExtension as si, StreamingTransactionalQueryAdapter as sl, defaultValues as sn, ComparisonValidation as so, union as sr, NativeStorage as ss, createDialect as st, Fragment as su, AnySchema as t, TableIndex as ta, SqliteIdentityExtension as tc, SqlOrderable as td, schemaNamingPolicyVersion as ti, QubuTransaction as tl, orderBy as tn, sql as to, recursiveCte as tr, ColumnStorageOf as ts, PortableCastTarget as tt, CapabilitiesOf as tu, SnapshotDecodeResult as u, SelectPart as ua, SchemaMetadataDiagnostic as uc, FieldLike as ui, execute as ul, values as un, gte as uo, fullJoin as ur, PortableStorage as us, Query as ut, GroupingKeysOf as uu, SnapshotExtensionContext as v, offset as va, isValidSchemaObjectName as vc, KeyConstraintOptions as vi, render as vl, doUpdate as vn, between as vo, FromSource as vr, bigint as vs, CustomSource as vt, NullabilityOf as vu, SnapshotIndexTermExpression as w, add as wa, ExecutionRequest as wc, SourceLike as wi, ColumnReference as wl, AllowAllClause as wn, Operand as wo, all as wr, encodeColumnParameter as ws, SourceConfig as wt, ProvidesSourceMeta as wu, SnapshotIdentity as x, AnySelectClause as xa, AdapterExecutionResult as xc, ReferentialAction as xi, QueryValidationErrorCode as xl, UpdateAssignmentValue as xn, isNotNull as xo, SelectionObject as xr, column as xs, ProvidedSourceRow as xt, OutputOf as xu, SnapshotForeignKey as y, having as ya, materializeSchemaObjectIdentity as yc, MysqlConstraintExtension as yi, QueryTypeValidation as yl, excluded as yn, inList as yo, from as yr, binary as ys, CustomSourceOptions as yt, NullableSourceMeta as yu, schemaSnapshotVersion as z, coalesce as za, HookOutcome as zc, AliasIdentity as zi, markExpressionCategory as zl, correlate as zn, ColumnGeneratedOf as zo, renderSchemaExpression as zr, ColumnDefaultInput as zs, TableColumns as zt, fragment as zu };

package/dist/{types-JSZHpUEj.d.mts → types-CTCqtFlS.d.mts}

@@ -1,4 +1,4 @@
-import { n as SchemaSnapshot } from "./types-BK1COGZe.mjs";
+import { n as SchemaSnapshot } from "./types-C0VkiwpR.mjs";
 //#region src/introspection/connection.d.ts
 /** A parameterized statement owned by a catalog adapter. */
 interface CatalogQuery {

package/dist/{types-JM3FcAnX.mjs → types-CTENnDh9.mjs}

@@ -1,7 +1,7 @@
 import { s as resolveCastTarget } from "./json-Db7XRD91.mjs";
 import { t as standardDialect } from "./standard-DfcZEVOj.mjs";
-import { H as makeSchemaExpression, K as fragment, V as makeExpression, u as columnResultValue } from "./column-hqKr7-1I.mjs";
-import { t as asValue } from "./value-Bi71Agyf.mjs";
+import { H as makeExpression, U as makeSchemaExpression, q as fragment, u as columnResultValue } from "./column-DmazTL67.mjs";
+import { t as asValue } from "./value-BEEj_Ayd.mjs";
 //#region src/core/render.ts
 function render(query, options = {}) {
 	const dialect = isDialect(options) ? options : options.dialect ?? standardDialect();

package/dist/{value-Bi71Agyf.mjs → value-BEEj_Ayd.mjs}

@@ -1,4 +1,4 @@
-import { H as makeSchemaExpression, K as fragment } from "./column-hqKr7-1I.mjs";
+import { U as makeSchemaExpression, q as fragment } from "./column-DmazTL67.mjs";
 //#region src/core/primitives/parameter.ts
 function parameter(_value) {
 	return fragment((context) => context.parameter(_value));

package/dist/vite/ambient.d.ts

@@ -136,10 +136,16 @@ declare global {
   type ColumnDefinitionConfig = import("qubu").ColumnDefinitionConfig
   type ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> =
     import("qubu").ColumnDefinition<TConfig>
+  type ColumnCodec<
+    TOutput = unknown,
+    TInsert = TOutput,
+    TDriver = unknown,
+  > = import("qubu").ColumnCodec<TOutput, TInsert, TDriver>
   type ColumnSqlType<T> = import("qubu").ColumnSqlType<T>
   type ColumnDefault = import("qubu").ColumnDefault
   type ColumnDefaultInput = import("qubu").ColumnDefaultInput
   type ColumnDefaultOf<T> = import("qubu").ColumnDefaultOf<T>
+  type ColumnHasRuntimeDefault<T> = import("qubu").ColumnHasRuntimeDefault<T>
   type ColumnGeneratedOf<T> = import("qubu").ColumnGeneratedOf<T>
   type ColumnIdentityOf<T> = import("qubu").ColumnIdentityOf<T>
   type ColumnOnUpdateOf<T> = import("qubu").ColumnOnUpdateOf<T>

package/docs/dialects-and-execution.md

@@ -353,6 +353,53 @@ const rows = await db.rows(readQuery)
 array. Both methods infer each row from the query projection. They do not make
 query values executable or transfer connection ownership to Qubu.
 
+## Observe bound operations
+
+Configure hooks on a bound client when logs, traces, or metrics need the same
+lifecycle view across queries, streams, plans, and transactions:
+
+```ts
+import { qubu } from "qubu"
+
+const db = qubu(adapter, {
+  hooks: {
+    onOperationStart(operation) {
+      console.info("Qubu operation started", operation)
+
+      return (outcome) => {
+        console.info("Qubu operation finished", operation.id, outcome)
+      }
+    },
+    onHookError(error) {
+      console.error("Qubu hook failed", error)
+    },
+  },
+})
+
+await db.rows(readQuery, {
+  hookMetadata: { operation: "users.list" },
+})
+```
+
+Query operations start after rendering and immediately before the adapter is
+called. Completion reports duration, success or the original error, and
+available aggregate facts such as row and affected-row counts. Transaction
+queries identify their parent transaction operation. Hooks are synchronous,
+and their failures are sent to `onHookError` without changing the database
+operation's result.
+
+Hook metadata accepts only strings, numbers, and booleans. Observations include
+rendered SQL and parameter count, but never parameter values, result rows,
+decoded values, or insert identifiers. Rendered SQL can still contain literals
+introduced by unsafe SQL helpers, so treat it according to the application's
+logging policy.
+
+Streaming adapters are still called eagerly. A consumed stream completes its
+observation when it is exhausted, closed early, or fails. A stream created but
+never consumed has no completion observation. Hooks are available only on
+clients created with `qubu()`; standalone execution functions remain
+unobserved.
+
 ## Run a transaction
 
 Use a transactional adapter when several queries must share one commit or

package/docs/guides/drizzle.md

@@ -75,7 +75,8 @@ Unix timestamps and Drizzle must continue reading and writing `Date` values:
 
 ```ts
 import { schema, table } from "qubu"
-import { sqliteTimestamp, toSqliteDrizzleSchema } from "@qubu/drizzle/sqlite"
+import { toSqliteDrizzleSchema } from "@qubu/drizzle/sqlite"
+import { sqliteTimestamp } from "qubu/sqlite"
 
 const events = table("events", {
   createdAt: sqliteTimestamp({

package/docs/reference/supported-surface.md

@@ -17,7 +17,7 @@
 | `qubu/postgres`          | Runtime          | PostgreSQL query dialect helpers such as `postgresDialect()` and `ilike()`                                       |
 | `qubu/schema`            | Runtime          | Advanced schema metadata, storage and constraint models, source models, and schema-expression extensions         |
 | `qubu/snapshot`          | Runtime          | Canonical Snapshot v1 and v2 traversal, encoding, decoding, diagnostics, and digests                             |
-| `qubu/sqlite`            | Runtime          | The SQLite query dialect policy                                                                                  |
+| `qubu/sqlite`            | Runtime          | The SQLite query dialect policy and native SQLite column factories                                               |
 | `qubu/vite`              | Runtime          | The optional `qubu()` Vite compiler hint                                                                         |
 | `qubu/package.json`      | JSON             | The published package manifest                                                                                   |
 | `@qubu/drizzle`          | Runtime          | Shared Drizzle conversion errors and dialect types                                                               |

package/docs/schema/columns-and-writes.md

@@ -69,6 +69,20 @@ Contradictory flags fail with a structured `ColumnBehaviorError`. Use
 `externalDefault()` or `externalGeneratedColumn()` when another schema authority
 owns the missing detail.
 
+Use `defaultFn` when Qubu should supply an omitted insert value at runtime:
+
+```ts
+const sessions = table("sessions", {
+  token: text({ defaultFn: () => crypto.randomUUID() }),
+})
+```
+
+Runtime defaults make the insert key optional and run once for each omitted
+row value. They remain live column behavior: snapshots and emitted DDL do not
+record a database default. A column may declare both `default` and `defaultFn`;
+Qubu writes use the runtime value while the database default remains available
+to other clients.
+
 Dialect-owned identity details stay on the identity descriptor. SQLite's
 autoIncrement requires an exact INTEGER rowid alias that is the sole column of
 a primary key. MySQL's AUTO_INCREMENT is a column-level identity extension, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qubu",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "repository": {
     "type": "git",
     "url": "https://github.com/aleclarson/qubu"