@holo-js/db 0.1.9 → 0.2.0

package/dist/index.d.ts

@@ -1,3 +1,27 @@
+/**
+ * Capability flags exposed by a driver+dialect pair.
+ *
+ * The new architecture uses explicit capabilities instead of branching on
+ * driver names throughout the ORM.
+ */
+interface DatabaseCapabilities {
+    returning: boolean;
+    savepoints: boolean;
+    concurrentQueries: boolean;
+    workerThreadExecution: boolean;
+    lockForUpdate: boolean;
+    sharedLock: boolean;
+    jsonValueQuery: boolean;
+    jsonContains: boolean;
+    jsonLength: boolean;
+    schemaQualifiedIdentifiers: boolean;
+    nativeUpsert: boolean;
+    ddlAlterSupport: boolean;
+    introspection: boolean;
+}
+declare const DEFAULT_CAPABILITIES: DatabaseCapabilities;
+declare function createCapabilities(overrides?: Partial<DatabaseCapabilities>): DatabaseCapabilities;
+
 type LogicalColumnKind = 'id' | 'integer' | 'bigInteger' | 'string' | 'text' | 'boolean' | 'real' | 'decimal' | 'date' | 'datetime' | 'timestamp' | 'json' | 'blob' | 'uuid' | 'ulid' | 'snowflake' | 'vector' | 'enum';
 type ColumnDefaultKind = 'value' | 'now';
 type IdGenerationStrategy = 'autoIncrement' | 'uuid' | 'ulid' | 'snowflake';
@@ -168,171 +192,6 @@ declare function renderGeneratedSchemaPlaceholder(): string;
 declare function renderGeneratedSchemaModule(tables: readonly TableDefinition[]): string;
 declare function renderGeneratedSchemaRuntimeModule(tables: readonly TableDefinition[]): string;
 
-type EntityConstructor = {
-    new <TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap>(repository: unknown, attributes: Partial<ModelRecord<TTable>>, exists?: boolean): Entity<TTable, TRelations>;
-    prototype: Entity<TableDefinition, RelationMap>;
-};
-
-declare class EntityBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> {
-    private readonly repository;
-    private attributes;
-    private original;
-    private changes;
-    private persisted;
-    private relations;
-    private relationLoads;
-    private peerCollection?;
-    private hiddenOverrides;
-    private visibleOverrides;
-    private visibleOnly;
-    private appendedOverrides;
-    constructor(repository: ModelRepositoryLike<TTable, EmptyScopeMap, TRelations>, attributes: Partial<ModelRecord<TTable>>, exists?: boolean);
-    getRepository(): ModelRepositoryLike<TTable>;
-    private getRepositoryRuntime;
-    is(other: unknown): boolean;
-    isNot(other: unknown): boolean;
-    exists(): boolean;
-    trashed(): boolean;
-    get<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey): ModelRecord<TTable>[TKey];
-    set<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey, value: ModelRecord<TTable>[TKey]): this;
-    fill(values: Partial<ModelRecord<TTable>>): this;
-    update(values: ModelUpdatePayload<TTable>): Promise<this>;
-    forceFill(values: Partial<ModelRecord<TTable>>): this;
-    isDirty(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
-    isClean(): boolean;
-    getDirty(): Partial<ModelUpdatePayload<TTable>>;
-    getChanges(): Partial<ModelUpdatePayload<TTable>>;
-    wasChanged(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
-    syncOriginal(): this;
-    syncChanges(): this;
-    syncPersisted(entity: EntityBase<TTable>, changes?: Record<string, unknown>): this;
-    bindPeerCollection(peers: readonly EntityBase<TTable, TRelations>[]): this;
-    getPeerCollection(): readonly EntityBase<TTable, TRelations>[] | undefined;
-    getPendingRelationLoad(name: string): Promise<unknown> | undefined;
-    setPendingRelationLoad(name: string, load: Promise<unknown>): this;
-    clearPendingRelationLoad(name: string): this;
-    toAttributes(): ModelRecord<TTable>;
-    setRelation(name: string, value: unknown): this;
-    setComputed(name: string, value: unknown): this;
-    makeHidden(...keys: readonly string[]): this;
-    makeVisible(...keys: readonly string[]): this;
-    setHidden(keys: readonly string[]): this;
-    setVisible(keys: readonly string[]): this;
-    append(...keys: readonly string[]): this;
-    setAppends(keys: readonly string[]): this;
-    withoutAppends(): this;
-    getRelation<TRelation = unknown>(name: string): TRelation;
-    hasRelation(name: string): boolean;
-    getLoadedRelations(): Readonly<Record<string, unknown>>;
-    getSerializationConfig(): {
-        readonly hidden: ReadonlySet<string>;
-        readonly visible: ReadonlySet<string>;
-        readonly visibleOnly: readonly string[] | null;
-        readonly appended: readonly string[] | null;
-    };
-    forgetRelation(name: string): this;
-    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
-    toJSON(): ModelRecord<TTable>;
-    private applyPersistedEntity;
-    private persistEntity;
-    private deletePersistedEntity;
-    private restoreEntity;
-    private forceDeletePersistedEntity;
-    private loadAggregateDefinitions;
-    save(): Promise<this>;
-    push(): Promise<this>;
-    saveQuietly(): Promise<this>;
-    delete(): Promise<void>;
-    deleteQuietly(): Promise<void>;
-    restore(): Promise<this>;
-    restoreQuietly(): Promise<this>;
-    forceDelete(): Promise<void>;
-    forceDeleteQuietly(): Promise<void>;
-    fresh(): Promise<Entity<TTable, TRelations> | undefined>;
-    refresh(): Promise<this>;
-    replicate(except?: readonly string[]): Entity<TTable, TRelations>;
-    load<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
-        toJSON(): infer R;
-    } ? {
-        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    } : {
-        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    })>;
-    loadMissing<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
-        toJSON(): infer R;
-    } ? {
-        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    } : {
-        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
-    })>;
-    loadMorph(relation: ModelRelationName<TRelations>, mapping: ModelMorphLoadMap): Promise<this>;
-    loadCount(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
-    loadExists(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
-    loadSum<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadAvg<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadMin<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    loadMax<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
-    associate<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated> | null): this;
-    dissociate(relation: string): this;
-    saveRelated<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
-    saveManyRelated<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
-    saveRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
-    saveManyRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
-    createRelated(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
-    createManyRelated(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
-    createRelatedQuietly(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
-    createManyRelatedQuietly(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
-    attach(relation: string, ids: unknown, attributes?: Record<string, unknown>): Promise<void>;
-    detach(relation: string, ids?: unknown): Promise<number>;
-    sync(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-        updated: unknown[];
-    }>;
-    syncWithoutDetaching(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-        updated: unknown[];
-    }>;
-    updateExistingPivot(relation: string, id: unknown, attributes: Record<string, unknown>): Promise<number>;
-    toggle(relation: string, ids: unknown): Promise<{
-        attached: unknown[];
-        detached: unknown[];
-    }>;
-}
-type ModelRelationMethods<TRelations extends RelationMap> = string extends ModelRelationName<TRelations> ? Record<never, never> : {
-    [K in ModelRelationName<TRelations>]: () => RelationMethodsOf<TRelations[K]>;
-};
-type ModelBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = EntityBase<TTable, TRelations> & ModelRecord<TTable> & {
-    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
-};
-type Entity<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = ModelBase<TTable, TRelations> & ModelRelationMethods<TRelations>;
-declare const Entity: EntityConstructor;
-
-/**
- * Capability flags exposed by a driver+dialect pair.
- *
- * The new architecture uses explicit capabilities instead of branching on
- * driver names throughout the ORM.
- */
-interface DatabaseCapabilities {
-    returning: boolean;
-    savepoints: boolean;
-    concurrentQueries: boolean;
-    workerThreadExecution: boolean;
-    lockForUpdate: boolean;
-    sharedLock: boolean;
-    jsonValueQuery: boolean;
-    jsonContains: boolean;
-    jsonLength: boolean;
-    schemaQualifiedIdentifiers: boolean;
-    nativeUpsert: boolean;
-    ddlAlterSupport: boolean;
-    introspection: boolean;
-}
-declare const DEFAULT_CAPABILITIES: DatabaseCapabilities;
-declare function createCapabilities(overrides?: Partial<DatabaseCapabilities>): DatabaseCapabilities;
-
 interface SecurityPolicy {
     allowUnsafeRawSql: boolean;
     debugSqlInLogs: boolean;
@@ -413,6 +272,10 @@ interface DatabaseOperationOptions {
     signal?: AbortSignal;
     timeoutMs?: number;
 }
+type TransactionMode = 'deferred' | 'immediate' | 'exclusive';
+interface DatabaseTransactionOptions extends DatabaseOperationOptions {
+    mode?: TransactionMode;
+}
 type TransactionCallback = () => void | Promise<void>;
 interface UnsafeStatement {
     unsafe: true;
@@ -474,11 +337,13 @@ interface DriverAdapter {
     initialize(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
+    isDatabaseMissingError?(error: unknown): boolean;
+    ensureDatabaseExists?(): Promise<void>;
     runWithTransactionScope?<T>(callback: () => Promise<T>): Promise<T>;
     introspect?<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    beginTransaction(options?: DatabaseOperationOptions): Promise<void>;
+    beginTransaction(options?: DatabaseTransactionOptions): Promise<void>;
     commit(options?: DatabaseOperationOptions): Promise<void>;
     rollback(options?: DatabaseOperationOptions): Promise<void>;
     createSavepoint?(name: string, options?: DatabaseOperationOptions): Promise<void>;
@@ -808,12 +673,27 @@ interface DatabaseQueryCacheBridge {
         readonly driver?: string;
     }): Promise<void>;
 }
+interface DatabaseDependencyInvalidationEvent {
+    readonly connectionName: string;
+    readonly dependencies: readonly string[];
+}
+type DatabaseDependencyInvalidationListener = (event: DatabaseDependencyInvalidationEvent) => void | Promise<void>;
+interface DatabaseDependencyCollectionResult<TValue> {
+    readonly value: TValue;
+    readonly dependencies: readonly string[];
+}
 declare function getQueryCacheBridgeState(): {
     bridge?: DatabaseQueryCacheBridge;
+    dependencyInvalidationListeners?: Set<DatabaseDependencyInvalidationListener>;
 };
 declare function configureDatabaseQueryCacheBridge(bridge?: DatabaseQueryCacheBridge): void;
 declare function getDatabaseQueryCacheBridge(): DatabaseQueryCacheBridge | undefined;
 declare function resetDatabaseQueryCacheBridge(): void;
+declare function onDatabaseDependencyInvalidated(listener: DatabaseDependencyInvalidationListener): () => void;
+declare function resetDatabaseDependencyInvalidationListeners(): void;
+declare function collectDatabaseQueryDependencies<TValue>(callback: () => TValue | Promise<TValue>): Promise<DatabaseDependencyCollectionResult<TValue>>;
+declare function recordDatabaseQueryDependencies(dependencies: readonly string[] | undefined): void;
+declare function notifyDatabaseDependencyInvalidationListeners(event: DatabaseDependencyInvalidationEvent): Promise<void>;
 declare function normalizeQueryCacheConfig(input: QueryCacheTtlInput | QueryCacheConfig): NormalizedQueryCacheConfig;
 declare function createDeterministicQueryCacheKey(statement: CompiledStatement, connectionName: string): string;
 declare function resolveQueryCacheKey(statement: CompiledStatement, connectionName: string, config: NormalizedQueryCacheConfig): string;
@@ -824,6 +704,7 @@ declare function supportsAutomaticQueryCacheInvalidation(plan: SelectQueryPlan):
 declare function inferAutomaticQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string): readonly string[] | undefined;
 declare function resolveQueryCacheDependencies(plan: SelectQueryPlan, connectionName: string, explicit?: readonly string[]): readonly string[] | undefined;
 declare const queryCacheInternals: {
+    collectDatabaseQueryDependencies: typeof collectDatabaseQueryDependencies;
     configureDatabaseQueryCacheBridge: typeof configureDatabaseQueryCacheBridge;
     createDeterministicQueryCacheKey: typeof createDeterministicQueryCacheKey;
     createTableCacheDependency: typeof createTableCacheDependency;
@@ -831,8 +712,12 @@ declare const queryCacheInternals: {
     inferAutomaticQueryCacheDependencies: typeof inferAutomaticQueryCacheDependencies;
     normalizeQueryCacheConfig: typeof normalizeQueryCacheConfig;
     normalizeQueryCacheDependencies: typeof normalizeQueryCacheDependencies;
+    notifyDatabaseDependencyInvalidationListeners: typeof notifyDatabaseDependencyInvalidationListeners;
+    onDatabaseDependencyInvalidated: typeof onDatabaseDependencyInvalidated;
+    recordDatabaseQueryDependencies: typeof recordDatabaseQueryDependencies;
     resolveQueryCacheDependencies: typeof resolveQueryCacheDependencies;
     resolveQueryCacheKey: typeof resolveQueryCacheKey;
+    resetDatabaseDependencyInvalidationListeners: typeof resetDatabaseDependencyInvalidationListeners;
     supportsAutomaticPredicateInvalidation: typeof supportsAutomaticPredicateInvalidation;
     supportsAutomaticQueryCacheInvalidation: typeof supportsAutomaticQueryCacheInvalidation;
 };
@@ -1142,6 +1027,8 @@ declare class TableQueryBuilder<TTableOrName extends TableReference = string, TS
     private whereFullTextWithBoolean;
     private whereVectorSimilarToWithBoolean;
     private prepareCursorPaginationQuery;
+    private resolveCursorOrders;
+    private readCursorColumnValue;
     private aggregateNumeric;
     private extractNumericValues;
     private normalizeUpdateValues;
@@ -1711,6 +1598,8 @@ declare class ModelQueryBuilder<TTable extends TableDefinition = TableDefinition
     private extractNumericValues;
     private getUnpaginatedEntities;
     private prepareCursorPaginationQuery;
+    private resolveCursorOrders;
+    private readCursorColumnValue;
 }
 
 type ModelInsertPayload<TTable extends TableDefinition> = Partial<InferInsert<TTable>>;
@@ -2066,7 +1955,9 @@ type ResolveEagerLoadUnion<TRelations extends RelationMap, TPaths extends string
  * - `Entity<T> | null`   → `ModelRecord<T> | null`
  * - `Entity<T> & { r: Entity<U>[] }` → `ModelRecord<T> & { r: ModelRecord<U>[] }`
  */
-type SerializeLoadedValue<TValue> = TValue extends readonly (infer TItem)[] ? SerializeLoadedValue<TItem>[] : TValue extends null ? null : TValue extends Entity<infer TTable, infer _TRelations> ? ModelRecord<TTable> & SerializeLoaded<Omit<TValue, keyof Entity<TTable, _TRelations>>> : TValue;
+type SerializeLoadedValue<TValue> = TValue extends readonly (infer TItem)[] ? SerializeLoadedValue<TItem>[] : TValue extends null ? null : TValue extends {
+    toJSON(): infer TSerialized;
+} ? TSerialized : TValue extends Entity<infer TTable, infer _TRelations> ? ModelRecord<TTable> & SerializeLoaded<Omit<TValue, keyof Entity<TTable, _TRelations>>> : TValue;
 type SerializeLoaded<TLoaded> = unknown extends TLoaded ? unknown : {
     readonly [K in keyof TLoaded]: SerializeLoadedValue<TLoaded[K]>;
 };
@@ -2215,6 +2106,147 @@ interface ModelRepositoryLike<TTable extends TableDefinition = TableDefinition,
     getConnection(): DatabaseContext;
 }
 
+type EntityConstructor = {
+    new <TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap>(repository: unknown, attributes: Partial<ModelRecord<TTable>>, exists?: boolean): Entity<TTable, TRelations>;
+    prototype: Entity<TableDefinition, RelationMap>;
+};
+
+declare class EntityBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> {
+    private readonly repository;
+    private attributes;
+    private original;
+    private changes;
+    private persisted;
+    private relations;
+    private relationLoads;
+    private peerCollection?;
+    private hiddenOverrides;
+    private visibleOverrides;
+    private visibleOnly;
+    private appendedOverrides;
+    constructor(repository: ModelRepositoryLike<TTable, EmptyScopeMap, TRelations>, attributes: Partial<ModelRecord<TTable>>, exists?: boolean);
+    getRepository(): ModelRepositoryLike<TTable>;
+    private getRepositoryRuntime;
+    is(other: unknown): boolean;
+    isNot(other: unknown): boolean;
+    exists(): boolean;
+    trashed(): boolean;
+    get<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey): ModelRecord<TTable>[TKey];
+    set<TKey extends Extract<keyof ModelRecord<TTable>, string>>(key: TKey, value: ModelRecord<TTable>[TKey]): this;
+    fill(values: Partial<ModelRecord<TTable>>): this;
+    update(values: ModelUpdatePayload<TTable>): Promise<this>;
+    forceFill(values: Partial<ModelRecord<TTable>>): this;
+    isDirty(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
+    isClean(): boolean;
+    getDirty(): Partial<ModelUpdatePayload<TTable>>;
+    getChanges(): Partial<ModelUpdatePayload<TTable>>;
+    wasChanged(key?: Extract<keyof ModelRecord<TTable>, string>): boolean;
+    syncOriginal(): this;
+    syncChanges(): this;
+    syncPersisted(entity: EntityBase<TTable>, changes?: Record<string, unknown>): this;
+    bindPeerCollection(peers: readonly EntityBase<TTable, TRelations>[]): this;
+    getPeerCollection(): readonly EntityBase<TTable, TRelations>[] | undefined;
+    getPendingRelationLoad(name: string): Promise<unknown> | undefined;
+    setPendingRelationLoad(name: string, load: Promise<unknown>): this;
+    clearPendingRelationLoad(name: string): this;
+    toAttributes(): ModelRecord<TTable>;
+    setRelation(name: string, value: unknown): this;
+    setComputed(name: string, value: unknown): this;
+    makeHidden(...keys: readonly string[]): this;
+    makeVisible(...keys: readonly string[]): this;
+    setHidden(keys: readonly string[]): this;
+    setVisible(keys: readonly string[]): this;
+    append(...keys: readonly string[]): this;
+    setAppends(keys: readonly string[]): this;
+    withoutAppends(): this;
+    getRelation<TRelation = unknown>(name: string): TRelation;
+    hasRelation(name: string): boolean;
+    getLoadedRelations(): Readonly<Record<string, unknown>>;
+    getSerializationConfig(): {
+        readonly hidden: ReadonlySet<string>;
+        readonly visible: ReadonlySet<string>;
+        readonly visibleOnly: readonly string[] | null;
+        readonly appended: readonly string[] | null;
+    };
+    forgetRelation(name: string): this;
+    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
+    toJSON(): ModelRecord<TTable>;
+    private applyPersistedEntity;
+    private persistEntity;
+    private deletePersistedEntity;
+    private restoreEntity;
+    private forceDeletePersistedEntity;
+    private loadAggregateDefinitions;
+    save(): Promise<this>;
+    push(): Promise<this>;
+    saveQuietly(): Promise<this>;
+    delete(): Promise<void>;
+    deleteQuietly(): Promise<void>;
+    restore(): Promise<this>;
+    restoreQuietly(): Promise<this>;
+    forceDelete(): Promise<void>;
+    forceDeleteQuietly(): Promise<void>;
+    fresh(): Promise<Entity<TTable, TRelations> | undefined>;
+    refresh(): Promise<this>;
+    replicate(except?: readonly string[]): Entity<TTable, TRelations>;
+    load<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
+        toJSON(): infer R;
+    } ? {
+        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+    } : {
+        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+    })>;
+    loadMissing<TPaths extends readonly ModelRelationPath<TRelations>[]>(...relations: TPaths): Promise<Omit<this, keyof ResolveEagerLoads<TRelations, TPaths>> & ResolveEagerLoads<TRelations, TPaths> & (this extends {
+        toJSON(): infer R;
+    } ? {
+        toJSON(): R & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+    } : {
+        toJSON(): ModelRecord<TTable> & SerializeLoaded<ResolveEagerLoads<TRelations, TPaths>>;
+    })>;
+    loadMorph(relation: ModelRelationName<TRelations>, mapping: ModelMorphLoadMap): Promise<this>;
+    loadCount(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
+    loadExists(...relations: readonly ModelRelationName<TRelations>[]): Promise<this>;
+    loadSum<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
+    loadAvg<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
+    loadMin<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
+    loadMax<TRelationName extends ModelRelationName<TRelations>>(relation: TRelationName, column: RelatedColumnNameOfRelation<TRelations[TRelationName]>): Promise<this>;
+    associate<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated> | null): this;
+    dissociate(relation: string): this;
+    saveRelated<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
+    saveManyRelated<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
+    saveRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: Entity<TRelated>): Promise<Entity<TRelated>>;
+    saveManyRelatedQuietly<TRelated extends TableDefinition>(relation: string, related: readonly Entity<TRelated>[]): Promise<Entity<TRelated>[]>;
+    createRelated(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
+    createManyRelated(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
+    createRelatedQuietly(relation: string, values: Record<string, unknown>): Promise<Entity<TableDefinition>>;
+    createManyRelatedQuietly(relation: string, values: readonly Record<string, unknown>[]): Promise<Entity<TableDefinition>[]>;
+    attach(relation: string, ids: unknown, attributes?: Record<string, unknown>): Promise<void>;
+    detach(relation: string, ids?: unknown): Promise<number>;
+    sync(relation: string, ids: unknown): Promise<{
+        attached: unknown[];
+        detached: unknown[];
+        updated: unknown[];
+    }>;
+    syncWithoutDetaching(relation: string, ids: unknown): Promise<{
+        attached: unknown[];
+        detached: unknown[];
+        updated: unknown[];
+    }>;
+    updateExistingPivot(relation: string, id: unknown, attributes: Record<string, unknown>): Promise<number>;
+    toggle(relation: string, ids: unknown): Promise<{
+        attached: unknown[];
+        detached: unknown[];
+    }>;
+}
+type ModelRelationMethods<TRelations extends RelationMap> = string extends ModelRelationName<TRelations> ? Record<never, never> : {
+    [K in ModelRelationName<TRelations>]: () => RelationMethodsOf<TRelations[K]>;
+};
+type ModelBase<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = EntityBase<TTable, TRelations> & ModelRecord<TTable> & {
+    relation<K extends ModelRelationName<TRelations>>(name: K): RelationMethodsOf<TRelations[K]>;
+};
+type Entity<TTable extends TableDefinition = TableDefinition, TRelations extends RelationMap = RelationMap> = ModelBase<TTable, TRelations> & ModelRelationMethods<TRelations>;
+declare const Entity: EntityConstructor;
+
 interface FactoryEntityReference<TTable extends TableDefinition = TableDefinition> {
     attach(relation: string, ids: unknown, attributes?: Record<string, unknown>): Promise<void>;
     exists(): boolean;
@@ -2825,12 +2857,15 @@ declare class MigrationService {
     status(): Promise<MigrationStatus[]>;
     planSquash(archiveName?: string): Promise<MigrationSquashPlan>;
     migrate(options?: MigrateOptions): Promise<RegisteredMigrationDefinition[]>;
+    private ensureTrackingTableForMigration;
     rollback(options?: RollbackOptions): Promise<RegisteredMigrationDefinition[]>;
     getExecutionPolicy(): MigrationExecutionPolicy;
     private ensureTrackingTable;
     private getRanRecords;
     private createContext;
     private runMigrationLifecycle;
+    private isDatabaseMissingError;
+    private disconnectFailedConnection;
     private normalizeMigratedAt;
     private createMigrationLog;
     private runExclusively;
@@ -2923,7 +2958,8 @@ declare class DatabaseContext {
     queryCompiled<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     introspectCompiled<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     executeCompiled(statement: CompiledStatement, options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    transaction<T>(callback: (tx: DatabaseContext) => Promise<T>, options?: DatabaseOperationOptions): Promise<T>;
+    transaction<T>(callback: (tx: DatabaseContext) => Promise<T>, options?: DatabaseTransactionOptions): Promise<T>;
+    writeTransaction<T>(callback: (tx: DatabaseContext) => Promise<T>, options?: DatabaseTransactionOptions): Promise<T>;
     private _runRootTransaction;
     private _runSerializedRootTransaction;
     private _runNestedTransaction;
@@ -2941,6 +2977,8 @@ declare class DatabaseContext {
     private _callTransactionHook;
     private _guardOperation;
     private _assertValidOperationOptions;
+    private _assertValidTransactionOptions;
+    private _resolveWriteTransactionOptions;
     private _throwIfAborted;
     private _createGuardError;
 }
@@ -3002,7 +3040,8 @@ declare class ConnectionManager {
     connection(name?: string): DatabaseContext;
     initializeAll(): Promise<void>;
     disconnectAll(): Promise<void>;
-    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string): Promise<T>;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string, options?: DatabaseTransactionOptions): Promise<T>;
+    writeTransaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string, options?: DatabaseTransactionOptions): Promise<T>;
 }
 declare function createConnectionManager(options: ConnectionManagerOptions): ConnectionManager;
 
@@ -3014,7 +3053,12 @@ declare class DatabaseFacade {
     table<TTable extends TableDefinition>(table: TTable, connectionName?: string): TableQueryBuilder<TTable>;
     table(name: string, connectionName?: string): TableQueryBuilder<string>;
     raw(sql: string, bindings?: readonly unknown[], source?: string): UnsafeStatement;
-    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName?: string, options?: DatabaseOperationOptions): Promise<T>;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, options?: DatabaseTransactionOptions): Promise<T>;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName: string, options?: DatabaseTransactionOptions): Promise<T>;
+    transaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName: undefined, options?: DatabaseTransactionOptions): Promise<T>;
+    writeTransaction<T>(callback: (connection: DatabaseContext) => Promise<T>, options?: DatabaseTransactionOptions): Promise<T>;
+    writeTransaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName: string, options?: DatabaseTransactionOptions): Promise<T>;
+    writeTransaction<T>(callback: (connection: DatabaseContext) => Promise<T>, connectionName: undefined, options?: DatabaseTransactionOptions): Promise<T>;
     afterCommit(callback: () => void | Promise<void>, connectionName?: string): void;
     afterRollback(callback: () => void | Promise<void>, connectionName?: string): void;
     unsafeQuery<TRow extends Record<string, unknown> = Record<string, unknown>>(statement: UnsafeStatement, connectionName?: string, options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
@@ -3044,11 +3088,13 @@ declare abstract class LazyDriverAdapter implements DriverAdapter {
     initialize(): Promise<void>;
     disconnect(): Promise<void>;
     isConnected(): boolean;
+    ensureDatabaseExists(): Promise<void>;
+    isDatabaseMissingError(error: unknown): boolean;
     runWithTransactionScope<T>(callback: () => Promise<T>): Promise<T>;
     introspect<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     query<TRow extends Record<string, unknown> = Record<string, unknown>>(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverQueryResult<TRow>>;
     execute(sql: string, bindings?: readonly unknown[], options?: DatabaseOperationOptions): Promise<DriverExecutionResult>;
-    beginTransaction(options?: DatabaseOperationOptions): Promise<void>;
+    beginTransaction(options?: DatabaseTransactionOptions): Promise<void>;
     commit(options?: DatabaseOperationOptions): Promise<void>;
     rollback(options?: DatabaseOperationOptions): Promise<void>;
     createSavepoint(name: string, options?: DatabaseOperationOptions): Promise<void>;
@@ -3718,7 +3764,10 @@ declare function resetMorphRegistry(): void;
 type SerializableModel = {
     toJSON(): unknown;
 };
-type SerializeModels<TValue> = TValue extends Date ? Date : TValue extends SerializableModel ? ReturnType<TValue['toJSON']> : TValue extends readonly (infer TItem)[] ? SerializeModels<TItem>[] : TValue extends object ? {
+type MaterializeSerializedValue<TValue> = TValue extends Date ? Date : TValue extends readonly (infer TItem)[] ? MaterializeSerializedValue<TItem>[] : TValue extends (...args: never[]) => unknown ? TValue : TValue extends object ? {
+    [K in keyof TValue]: MaterializeSerializedValue<TValue[K]>;
+} : TValue;
+type SerializeModels<TValue> = TValue extends Date ? Date : TValue extends SerializableModel ? MaterializeSerializedValue<ReturnType<TValue['toJSON']>> : TValue extends readonly (infer TItem)[] ? SerializeModels<TItem>[] : TValue extends object ? {
     [K in keyof TValue]: SerializeModels<TValue[K]>;
 } : TValue;
 declare function serializeModels<TValue>(value: TValue): SerializeModels<TValue>;
@@ -3738,7 +3787,20 @@ interface UniqueSlugOptions<TTable extends TableDefinition, TColumn extends Stri
     readonly separator?: string;
     readonly fallback?: string;
 }
-type UniqueSlugModel<TTable extends TableDefinition, TScopes extends ModelScopesDefinition, TRelations extends RelationMap> = StaticModelApi<TTable, TScopes, TRelations>;
+type UniqueSlugModel<TTable extends TableDefinition, _TScopes extends ModelScopesDefinition, _TRelations extends RelationMap> = {
+    readonly definition: {
+        readonly connectionName?: string;
+        readonly name: string;
+        readonly primaryKey: string;
+    };
+    whereLike(column: ModelColumnName<TTable>, value: string): {
+        when(condition: boolean, callback: (query: {
+            where(column: string, operator: string, value: unknown): unknown;
+        }) => unknown): {
+            pluck<TColumn extends ModelAttributeKey<TTable>>(column: TColumn): Promise<Array<ModelRecord<TTable>[TColumn]>>;
+        };
+    };
+};
 declare function uniqueSlug<TTable extends TableDefinition, TScopes extends ModelScopesDefinition, TRelations extends RelationMap, TColumn extends StringModelAttributeKey<TTable> = Extract<'slug', StringModelAttributeKey<TTable>>>(model: UniqueSlugModel<TTable, TScopes, TRelations>, value: string, options?: UniqueSlugOptions<TTable, TColumn>): Promise<string>;
 
 declare function belongsTo<const TName extends RegisteredModelName>(related: TName, foreignKeyOrOptions: string | {
@@ -3855,4 +3917,4 @@ interface NormalizedHoloProjectConfig {
 declare function normalizeHoloProjectConfig(config?: HoloProjectConfig): NormalizedHoloProjectConfig;
 declare function defineHoloProject<TConfig extends HoloProjectConfig>(config: TConfig): NormalizedHoloProjectConfig & TConfig;
 
-export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, AsyncConnectionContext, type BelongsToManyRelationDefinition, type BelongsToRelationDefinition, type BoundTableDefinition, type BuiltInCastName, type BuiltInCastString, CapabilityError, type CastableDefinition, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, type CursorPaginationOptions, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DatabaseQueryCacheBridge, type DefineModelOptions, type DefineTableOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, type EmptyScopeMap, Entity, type EntityWithLoaded, type EnumCastDefinition, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, type HasManyRelationDefinition, type HasOneRelationDefinition, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, HydrationError, type IdGenerationStrategy, type InferInsert, type InferSelect, type InferUpdate, type InsertQueryPlan, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedIndex, type LogicalColumnKind, type MigrateOptions, type MigrationContext, type MigrationDefinition, type MigrationErrorLog, type MigrationExecutionPolicy, MigrationService, type MigrationSquashPlan, type MigrationStartLog, type MigrationStatus, type MigrationSuccessLog, type MigrationTemplateKind, type MigrationTemplateOptions, type ModelAttributeKey, type ModelCastDefinition, type ModelCollection, type ModelDefinition, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, ModelRepository, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, type PaginationOptions, type PivotRelationMethods, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryCacheConfig, type QueryCacheFlexibleTtlInput, type QueryCacheTtlInput, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RegisteredModelName, type RegisteredModelReference, type RegisteredModels, type RelationDefinition, RelationError, type RelationMap, type RenameColumnOperation, type RenameIndexOperation, type RenameTableOperation, type ResolveEagerLoadPath, type ResolveEagerLoadUnion, type ResolveEagerLoads, type RollbackOptions, type RuntimeConfigInput, type RuntimeConnectionConfig, type RuntimeDatabaseConfig, type RuntimeHoloConfig, SQLQueryCompiler, SQLSchemaCompiler, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteDatabaseLike, SQLiteQueryCompiler, SQLiteSchemaCompiler, type SQLiteStatementLike, type SchemaColumnMismatch, type SchemaDefaultDialectName, type SchemaDialectName, type SchemaDiff, SchemaError, type SchemaForeignKeyMismatch, type SchemaIndexMismatch, SchemaRegistry, SchemaService, type SchemaSyncPlan, SecurityError, type SecurityPolicy, type SeedOptions, type SeederContext, type SeederDefinition, type SeederErrorLog, SeederService, type SeederStartLog, type SeederSuccessLog, type SelectQueryPlan, SerializationError, type SerializeLoaded, type SerializeModels, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type StaticModelApi, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, column, compileDialectDefaultLiteral, configureDB, configureDatabaseQueryCacheBridge, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createMySQLAdapter, createPaginator, createPostgresAdapter, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, createSQLiteAdapter, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineHoloProject, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getDatabaseQueryCacheBridge, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeHoloProjectConfig, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, parseDatabaseDriver, queryCacheInternals, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, renderGeneratedSchemaRuntimeModule, resetDB, resetDatabaseQueryCacheBridge, resetGlobalModelRegistry, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, serializeModels, uniqueSlug, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };
+export { type AddColumnOperation, type AlterColumnOperation, type AnyColumnDefinition, type AnyModelDefinition, AsyncConnectionContext, type BelongsToManyRelationDefinition, type BelongsToManyRelationMethods, type BelongsToRelationDefinition, type BelongsToRelationMethods, type BoundTableDefinition, type BuiltInCastName, type BuiltInCastString, CapabilityError, type CastableDefinition, ColumnBuilder, type ColumnDefinition, type CompiledStatement, CompilerError, type ConcurrencyOptions, ConfigurationError, ConnectionManager, type ConnectionManagerOptions, type CreateForeignKeyOperation, type CreateIndexOperation, type CreateTableOperation, type CursorPaginatedResult, type CursorPaginationOptions, DB, type DDLOperation, type DDLStatement, DEFAULT_CAPABILITIES, DEFAULT_HOLO_PROJECT_PATHS, DEFAULT_SECURITY_POLICY, DIALECT_ID_STRATEGY_MAP, DIALECT_LOGICAL_TYPE_MAP, DIALECT_VECTOR_SUPPORT, type DatabaseCapabilities, DatabaseContext, type DatabaseContextOptions, type DatabaseDependencyCollectionResult, type DatabaseDependencyInvalidationEvent, type DatabaseDependencyInvalidationListener, type DatabaseDriverName, DatabaseError, type DatabaseLogger, type DatabaseOperationOptions, type DatabaseQueryCacheBridge, type DatabaseTransactionOptions, type DefineModelOptions, type DefineTableOptions, type DeleteQueryPlan, type Dialect, type DriverAdapter, type DriverExecutionResult, type DriverQueryResult, type DropColumnOperation, type DropForeignKeyOperation, type DropIndexOperation, type DropTableOperation, type DynamicRelationResolver, type EmptyScopeMap, Entity, type EntityWithLoaded, type EnumCastDefinition, Factory, type FactoryAttributes, type FactoryContext, type FactoryDefinition, type FactoryHook, type FactoryModelReference, FactoryService, type FactoryStateDefinition, type ForeignKeyReference, type GeneratedMigrationTemplate, type GeneratedSchemaTable, type GeneratedSchemaTableName, type GeneratedSchemaTables, type HasManyRelationDefinition, type HasManyRelationMethods, type HasManyThroughRelationDefinition, type HasOneOfManyRelationDefinition, type HasOneRelationDefinition, type HasOneRelationMethods, type HasOneThroughRelationDefinition, HasSnowflakes, HasUlids, HasUniqueIds, HasUuids, type HoloProjectConfig, type HoloProjectConnectionConfig, type HoloProjectDatabaseConfig, type HoloProjectPaths, HydrationError, type IdGenerationStrategy, type InferInsert, type InferSelect, type InferUpdate, type InsertQueryPlan, type IntrospectedColumn, type IntrospectedForeignKey, type IntrospectedIndex, type LogicalColumnKind, type MigrateOptions, type MigrationContext, type MigrationDefinition, type MigrationErrorLog, type MigrationExecutionPolicy, MigrationService, type MigrationSquashPlan, type MigrationStartLog, type MigrationStatus, type MigrationSuccessLog, type MigrationTemplateKind, type MigrationTemplateOptions, type ModelAttributeKey, type ModelCastDefinition, type ModelCollection, type ModelDefinition, type ModelDefinitionLike, ModelEventService, type ModelInsertPayload, ModelNotFoundException, ModelQueryBuilder, type ModelRecord, type ModelReference, ModelRegistry, type ModelRelationPath, ModelRepository, type ModelRepositoryLike, type ModelScopeArgs, type ModelScopeMap, type ModelTrait, type ModelUpdatePayload, type MorphManyRelationDefinition, type MorphOneOfManyRelationDefinition, type MorphOneRelationDefinition, type MorphToManyRelationDefinition, type MorphToRelationDefinition, type MorphedByManyRelationDefinition, MySQLAdapter, type MySQLAdapterOptions, type MySQLClientLike, type MySQLPoolLike, MySQLQueryCompiler, type MySQLQueryableLike, MySQLSchemaCompiler, type NormalizedHoloProjectConfig, type PaginatedResult, type PaginationMeta, type PaginationOptions, type PivotRelationMethods, PostgresAdapter, type PostgresAdapterOptions, type PostgresClientLike, type PostgresPoolLike, PostgresQueryCompiler, type PostgresQueryableLike, PostgresSchemaCompiler, type QueryCacheConfig, type QueryCacheFlexibleTtlInput, type QueryCacheTtlInput, type QueryDirection, type QueryOperator, type QueryOrderBy, type QueryPlan, type QueryPredicate, QueryScheduler, type QuerySelection, type QuerySource, type RegisteredModelName, type RegisteredModelReference, type RegisteredModels, type RelatedColumnNameForRelationPath, type RelationConstraintDefinition, type RelationDefinition, RelationError, type RelationMap, type RenameColumnOperation, type RenameIndexOperation, type RenameTableOperation, type ResolveEagerLoadPath, type ResolveEagerLoadUnion, type ResolveEagerLoads, type RollbackOptions, type RuntimeConfigInput, type RuntimeConnectionConfig, type RuntimeDatabaseConfig, type RuntimeHoloConfig, SQLQueryCompiler, SQLSchemaCompiler, SQLiteAdapter, type SQLiteAdapterOptions, type SQLiteDatabaseLike, SQLiteQueryCompiler, SQLiteSchemaCompiler, type SQLiteStatementLike, type SchemaColumnMismatch, type SchemaDefaultDialectName, type SchemaDialectName, type SchemaDiff, SchemaError, type SchemaForeignKeyMismatch, type SchemaIndexMismatch, SchemaRegistry, SchemaService, type SchemaSyncPlan, SecurityError, type SecurityPolicy, type SeedOptions, type SeederContext, type SeederDefinition, type SeederErrorLog, SeederService, type SeederStartLog, type SeederSuccessLog, type SelectQueryPlan, SerializationError, type SerializeLoaded, type SerializeModels, type SerializedEntityWithLoaded, type SimplePaginatedResult, type SimplePaginationMeta, type StaticModelApi, type SupportedDatabaseDriver, type TableColumnsShape, type TableDefinition, TableDefinitionBuilder, type TableIndexDefinition, TableMutationBuilder, TableQueryBuilder, type TableSchemaDiff, type TransactionCallback, TransactionError, type TransactionMode, type UniqueIdRuntimeConfig, type UniqueIdTrait, type UniqueIdTraitKind, type UnsafeStatement, type UpdateQueryPlan, type VectorValue, addColumnOperation, alterColumnOperation, belongsTo, belongsToMany, binaryCast, clearGeneratedTables, collectDatabaseQueryDependencies, column, compileDialectDefaultLiteral, configureDB, configureDatabaseQueryCacheBridge, connectionAsyncContext, createAdapter, createCapabilities, createConnectionManager, createCursorPaginator, createDatabase, createDeleteQueryPlan, createDialect, createFactoryService, createForeignKeyOperation, createIndexOperation, createInsertQueryPlan, createMigrationFileName, createMigrationService, createMigrationTimestamp, createModelCollection, createModelEventService, createModelRegistry, createMySQLAdapter, createPaginator, createPostgresAdapter, createQueryScheduler, createRuntimeConnectionOptions, createRuntimeLogger, createSQLiteAdapter, diffSchema as createSchemaDiff, createSchemaRegistry, createSchemaService, createSecurityPolicy, createSeederService, createSelectQueryPlan, createSimplePaginator, createTableOperation, createTableSource, createUpdateQueryPlan, defineFactory, defineGeneratedTable, defineHoloProject, defineMigration, defineModel, defineSeeder, diffSchema, dropColumnOperation, dropForeignKeyOperation, dropIndexOperation, dropTableOperation, encryptedCast, enumCast, generateMigrationTemplate, generateSnowflake, generateUlid, generateUuidV7, getDatabaseQueryCacheBridge, getGeneratedTableDefinition, getModelDefinition, hasMany, hasManyThrough, hasOne, hasOneThrough, inferMigrationTableName, inferMigrationTemplateKind, isSupportedDatabaseDriver, latestMorphOne, latestOfMany, listGeneratedTableDefinitions, morphMany, morphOfMany, morphOne, morphTo, morphToMany, morphedByMany, normalizeDialectReadValue, normalizeDialectWriteValue, normalizeHoloProjectConfig, normalizeMigrationSlug, ofMany, oldestMorphOne, oldestOfMany, onDatabaseDependencyInvalidated, parseDatabaseDriver, queryCacheInternals, recordDatabaseQueryDependencies, redactBindings, redactSql, registerGeneratedTables, renameColumnOperation, renameIndexOperation, renameTableOperation, renderGeneratedSchemaModule, renderGeneratedSchemaPlaceholder, renderGeneratedSchemaRuntimeModule, resetDB, resetDatabaseDependencyInvalidationListeners, resetDatabaseQueryCacheBridge, resetGlobalModelRegistry, resetMorphRegistry, resolveDialectColumnType, resolveDialectIdStrategyType, resolveGeneratedTableDefinition, resolveMorphModel, resolveRuntimeConnectionManagerOptions, scopeRelation, serializeModels, uniqueSlug, unsafeSql, validateQueryPlan, withLimit, withOffset, withOrderBy, withPredicate, withSelections };

package/dist/index.mjs

@@ -121,6 +121,8 @@ function redactSql(sql, policy) {
 
 // src/cache.ts
 import { createHash } from "crypto";
+import { AsyncLocalStorage } from "async_hooks";
+var databaseDependencyCollector = new AsyncLocalStorage();
 function getQueryCacheBridgeState() {
   const runtime = globalThis;
   runtime.__holoDbQueryCacheBridge__ ??= {};
@@ -135,6 +137,50 @@ function getDatabaseQueryCacheBridge() {
 function resetDatabaseQueryCacheBridge() {
   getQueryCacheBridgeState().bridge = void 0;
 }
+function onDatabaseDependencyInvalidated(listener) {
+  const state = getQueryCacheBridgeState();
+  state.dependencyInvalidationListeners ??= /* @__PURE__ */ new Set();
+  state.dependencyInvalidationListeners.add(listener);
+  return () => {
+    state.dependencyInvalidationListeners?.delete(listener);
+  };
+}
+function resetDatabaseDependencyInvalidationListeners() {
+  getQueryCacheBridgeState().dependencyInvalidationListeners = void 0;
+}
+async function collectDatabaseQueryDependencies(callback) {
+  const dependencies = /* @__PURE__ */ new Set();
+  const value = await databaseDependencyCollector.run(dependencies, callback);
+  return Object.freeze({
+    value,
+    dependencies: Object.freeze([...dependencies])
+  });
+}
+function recordDatabaseQueryDependencies(dependencies) {
+  if (!dependencies || dependencies.length === 0) {
+    return;
+  }
+  const active = databaseDependencyCollector.getStore();
+  if (!active) {
+    return;
+  }
+  for (const dependency of dependencies) {
+    active.add(dependency);
+  }
+}
+async function notifyDatabaseDependencyInvalidationListeners(event) {
+  const listeners = getQueryCacheBridgeState().dependencyInvalidationListeners;
+  if (!listeners || listeners.size === 0) {
+    return;
+  }
+  await Promise.all([...listeners].map(async (listener) => {
+    try {
+      await listener(event);
+    } catch (error) {
+      console.error("[@holo-js/db] Database dependency invalidation listener failed.", error);
+    }
+  }));
+}
 function normalizeQueryCacheConfig(input) {
   if (typeof input === "number" || input instanceof Date) {
     return Object.freeze({
@@ -238,19 +284,25 @@ function resolveQueryCacheDependencies(plan, connectionName, explicit) {
   return inferAutomaticQueryCacheDependencies(plan, connectionName);
 }
 async function invalidateQueryCacheDependencies(connection, dependencies) {
-  const bridge = getDatabaseQueryCacheBridge();
-  if (!bridge || dependencies.length === 0) {
+  if (dependencies.length === 0) {
     return;
   }
+  const invalidate = async () => {
+    const bridge = getDatabaseQueryCacheBridge();
+    await bridge?.invalidateDependencies(dependencies);
+    await notifyDatabaseDependencyInvalidationListeners({
+      connectionName: connection.getConnectionName(),
+      dependencies
+    });
+  };
   if (connection.getScope().kind === "root") {
-    await bridge.invalidateDependencies(dependencies);
+    await invalidate();
     return;
   }
-  connection.afterCommit(async () => {
-    await bridge.invalidateDependencies(dependencies);
-  });
+  connection.afterCommit(invalidate);
 }
 var queryCacheInternals = {
+  collectDatabaseQueryDependencies,
   configureDatabaseQueryCacheBridge,
   createDeterministicQueryCacheKey,
   createTableCacheDependency,
@@ -258,8 +310,12 @@ var queryCacheInternals = {
   inferAutomaticQueryCacheDependencies,
   normalizeQueryCacheConfig,
   normalizeQueryCacheDependencies,
+  notifyDatabaseDependencyInvalidationListeners,
+  onDatabaseDependencyInvalidated,
+  recordDatabaseQueryDependencies,
   resolveQueryCacheDependencies,
   resolveQueryCacheKey,
+  resetDatabaseDependencyInvalidationListeners,
   supportsAutomaticPredicateInvalidation,
   supportsAutomaticQueryCacheInvalidation
 };
@@ -296,24 +352,56 @@ function normalizePaginationParameterName(value, fallback, createError) {
   }
   return trimmed;
 }
-function encodeOffsetCursor(offset) {
-  return Buffer.from(JSON.stringify({ offset }), "utf8").toString("base64url");
+function encodeValueCursor(values) {
+  return Buffer.from(JSON.stringify({ values }), "utf8").toString("base64url");
 }
-function decodeOffsetCursor(cursor, createError) {
+function decodeValueCursor(cursor, createError) {
   if (cursor === null) {
-    return 0;
+    return null;
   }
   try {
     const decoded = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-    const offset = decoded.offset;
-    if (typeof offset !== "number" || !Number.isInteger(offset) || offset < 0) {
-      throw new Error("invalid offset");
+    if (!Array.isArray(decoded.values)) {
+      throw new Error("invalid cursor values");
     }
-    return offset;
+    return { values: decoded.values };
   } catch {
     throw createError("Cursor is malformed.");
   }
 }
+function normalizeComparableValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Date) {
+    return value.getTime();
+  }
+  return String(value);
+}
+function compareCursorValues(left, right) {
+  const normalizedLeft = normalizeComparableValue(left);
+  const normalizedRight = normalizeComparableValue(right);
+  if (normalizedLeft === normalizedRight) {
+    return 0;
+  }
+  if (normalizedLeft === null) {
+    return -1;
+  }
+  if (normalizedRight === null) {
+    return 1;
+  }
+  return normalizedLeft < normalizedRight ? -1 : 1;
+}
+function isRowAfterCursor(rowValues, cursorValues, orders) {
+  for (const [index, order] of orders.entries()) {
+    const comparison = compareCursorValues(rowValues[index], cursorValues[index]);
+    if (comparison === 0) {
+      continue;
+    }
+    return order.direction === "asc" ? comparison > 0 : comparison < 0;
+  }
+  return false;
+}
 
 // src/query/paginator.ts
 function createPaginator(data, meta) {
@@ -2721,6 +2809,12 @@ var TableQueryBuilder = class _TableQueryBuilder {
   async get() {
     const statement = this.toSQL();
     const cacheConfig = this.queryCacheConfig;
+    const dependencies = this.plan.lockMode ? void 0 : resolveQueryCacheDependencies(
+      this.plan,
+      this.connection.getConnectionName(),
+      cacheConfig?.invalidate
+    );
+    recordDatabaseQueryDependencies(dependencies);
     if (!cacheConfig || this.plan.lockMode) {
       const result = await this.connection.queryCompiled(statement);
       return result.rows;
@@ -2730,11 +2824,6 @@ var TableQueryBuilder = class _TableQueryBuilder {
       throw new ConfigurationError("[@holo-js/db] Query caching requires @holo-js/cache to be installed and configured.");
     }
     const cacheKey = resolveQueryCacheKey(statement, this.connection.getConnectionName(), cacheConfig);
-    const dependencies = resolveQueryCacheDependencies(
-      this.plan,
-      this.connection.getConnectionName(),
-      cacheConfig.invalidate
-    );
     if (cacheConfig.flexible) {
       return bridge.flexible(
         cacheKey,
@@ -2820,16 +2909,23 @@ var TableQueryBuilder = class _TableQueryBuilder {
   async cursorPaginate(perPage = 15, cursor = null, options = {}) {
     assertPositiveInteger(perPage, "Per-page value", (message) => new SecurityError(message));
     const cursorName = normalizePaginationParameterName(options.cursorName, "cursor", (message) => new SecurityError(message));
-    const offset = decodeOffsetCursor(cursor, (message) => new SecurityError(message));
+    const decodedCursor = decodeValueCursor(cursor, (message) => new SecurityError(message));
     const orderedQuery = this.prepareCursorPaginationQuery();
+    const cursorOrders = orderedQuery.resolveCursorOrders();
     const rows = await orderedQuery.getUnpaginatedRows();
-    const pageRows = rows.slice(offset, offset + perPage + 1);
+    const filteredRows = decodedCursor ? rows.filter((row) => isRowAfterCursor(
+      cursorOrders.map((order) => orderedQuery.readCursorColumnValue(row, order.column)),
+      decodedCursor.values,
+      cursorOrders
+    )) : rows;
+    const pageRows = filteredRows.slice(0, perPage + 1);
     const hasMorePages = pageRows.length > perPage;
     const data = hasMorePages ? pageRows.slice(0, perPage) : pageRows;
+    const lastRow = data.at(-1);
     return createCursorPaginator(data, {
       perPage,
       cursorName,
-      nextCursor: hasMorePages ? encodeOffsetCursor(offset + perPage) : null,
+      nextCursor: hasMorePages && lastRow ? encodeValueCursor(cursorOrders.map((order) => orderedQuery.readCursorColumnValue(lastRow, order.column))) : null,
       prevCursor: cursor
     });
   }
@@ -3154,6 +3250,24 @@ var TableQueryBuilder = class _TableQueryBuilder {
     }
     return this;
   }
+  resolveCursorOrders() {
+    return this.plan.orderBy.map((orderBy) => {
+      if (orderBy.kind !== "column") {
+        throw new SecurityError("Cursor pagination requires column orderBy clauses.");
+      }
+      return {
+        column: orderBy.column,
+        direction: orderBy.direction
+      };
+    });
+  }
+  readCursorColumnValue(row, column2) {
+    if (column2 in row) {
+      return row[column2];
+    }
+    const unqualifiedColumn = column2.split(".").at(-1);
+    return unqualifiedColumn ? row[unqualifiedColumn] : void 0;
+  }
   async aggregateNumeric(column2, kind) {
     const rows = await this.get();
     if (rows.length === 0) {
@@ -6230,7 +6344,7 @@ var MigrationService = class {
   }
   async migrate(options = {}) {
     return this.runExclusively(async () => {
-      await this.ensureTrackingTable();
+      await this.ensureTrackingTableForMigration();
       const step = options.step ?? Number.POSITIVE_INFINITY;
       const ran = await this.getRanRecords();
       const ranNames = new Set(ran.map((record) => record.name));
@@ -6255,6 +6369,22 @@ var MigrationService = class {
       return executed;
     });
   }
+  async ensureTrackingTableForMigration() {
+    try {
+      await this.ensureTrackingTable();
+    } catch (error) {
+      if (!this.isDatabaseMissingError(error)) {
+        throw error;
+      }
+      const adapter = this.connection.getAdapter();
+      if (typeof adapter.ensureDatabaseExists !== "function") {
+        throw error;
+      }
+      await this.disconnectFailedConnection();
+      await adapter.ensureDatabaseExists();
+      await this.ensureTrackingTable();
+    }
+  }
   async rollback(options = {}) {
     return this.runExclusively(async () => {
       await this.ensureTrackingTable();
@@ -6338,6 +6468,22 @@ var MigrationService = class {
       throw error;
     }
   }
+  isDatabaseMissingError(error) {
+    const adapter = this.connection.getAdapter();
+    if (typeof adapter.isDatabaseMissingError !== "function") {
+      return false;
+    }
+    if (adapter.isDatabaseMissingError(error)) {
+      return true;
+    }
+    return error instanceof DatabaseError && typeof error.cause !== "undefined" && adapter.isDatabaseMissingError(error.cause);
+  }
+  async disconnectFailedConnection() {
+    if (!this.connection.isConnected()) {
+      return;
+    }
+    await this.connection.disconnect();
+  }
   normalizeMigratedAt(value) {
     const normalized = value instanceof Date ? value : new Date(value);
     if (Number.isNaN(normalized.getTime())) {
@@ -6374,9 +6520,9 @@ function createMigrationService(connection, migrations = []) {
 }
 
 // src/model/eventState.ts
-import { AsyncLocalStorage } from "async_hooks";
-var eventMuteStorage = new AsyncLocalStorage();
-var guardBypassStorage = new AsyncLocalStorage();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+var eventMuteStorage = new AsyncLocalStorage2();
+var guardBypassStorage = new AsyncLocalStorage2();
 function areModelEventsMuted() {
   return (eventMuteStorage.getStore() ?? 0) > 0;
 }
@@ -6412,10 +6558,10 @@ function createModelEventService() {
 }
 
 // src/concurrency/AsyncConnectionContext.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "async_hooks";
+import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 function getAsyncConnectionStorage() {
   const runtime = globalThis;
-  runtime.__holoAsyncConnectionStorage__ ??= new AsyncLocalStorage2();
+  runtime.__holoAsyncConnectionStorage__ ??= new AsyncLocalStorage3();
   return runtime.__holoAsyncConnectionStorage__;
 }
 var AsyncConnectionContext = class {
@@ -6603,12 +6749,23 @@ var DatabaseFacade = class {
   raw(sql, bindings = [], source) {
     return unsafeSql(sql, bindings, source);
   }
-  async transaction(callback, connectionName, options) {
+  async transaction(callback, connectionNameOrOptions, options) {
+    const connectionName = typeof connectionNameOrOptions === "string" ? connectionNameOrOptions : void 0;
+    const transactionOptions = typeof connectionNameOrOptions === "string" ? options : options ?? connectionNameOrOptions;
     const target = this.connection(connectionName);
     return target.transaction((tx) => connectionAsyncContext.run({
       connectionName: tx.getConnectionName(),
       connection: tx
-    }, () => callback(tx)), options);
+    }, () => callback(tx)), transactionOptions);
+  }
+  async writeTransaction(callback, connectionNameOrOptions, options) {
+    const connectionName = typeof connectionNameOrOptions === "string" ? connectionNameOrOptions : void 0;
+    const transactionOptions = typeof connectionNameOrOptions === "string" ? options : options ?? connectionNameOrOptions;
+    const target = this.connection(connectionName);
+    return target.writeTransaction((tx) => connectionAsyncContext.run({
+      connectionName: tx.getConnectionName(),
+      connection: tx
+    }, () => callback(tx)), transactionOptions);
   }
   afterCommit(callback, connectionName) {
     this.connection(connectionName).afterCommit(callback);
@@ -8015,16 +8172,23 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
   async cursorPaginate(perPage = 15, cursor = null, options = {}) {
     assertPositiveInteger(perPage, "Per-page value", (message) => new HydrationError(message));
     const cursorName = normalizePaginationParameterName(options.cursorName, "cursor", (message) => new HydrationError(message));
-    const offset = decodeOffsetCursor(cursor, (message) => new HydrationError(message));
+    const decodedCursor = decodeValueCursor(cursor, (message) => new HydrationError(message));
     const orderedQuery = this.prepareCursorPaginationQuery();
+    const cursorOrders = orderedQuery.resolveCursorOrders();
     const entities = await orderedQuery.getUnpaginatedEntities();
-    const pageEntities = entities.slice(offset, offset + perPage + 1);
+    const filteredEntities = decodedCursor ? entities.filter((entity) => isRowAfterCursor(
+      cursorOrders.map((order) => orderedQuery.readCursorColumnValue(entity, order.column)),
+      decodedCursor.values,
+      cursorOrders
+    )) : entities;
+    const pageEntities = filteredEntities.slice(0, perPage + 1);
     const hasMorePages = pageEntities.length > perPage;
     const data = hasMorePages ? pageEntities.slice(0, perPage) : pageEntities;
+    const lastEntity = data.at(-1);
     return createCursorPaginator(this.repository.createCollection(data), {
       perPage,
       cursorName,
-      nextCursor: hasMorePages ? encodeOffsetCursor(offset + perPage) : null,
+      nextCursor: hasMorePages && lastEntity ? encodeValueCursor(cursorOrders.map((order) => orderedQuery.readCursorColumnValue(lastEntity, order.column))) : null,
       prevCursor: cursor
     });
   }
@@ -8501,6 +8665,22 @@ var ModelQueryBuilder = class _ModelQueryBuilder {
     }
     return this;
   }
+  resolveCursorOrders() {
+    const plan = this.tableQuery.getPlan();
+    return plan.orderBy.map((orderBy) => {
+      if (orderBy.kind !== "column") {
+        throw new HydrationError("Cursor pagination requires column orderBy clauses.");
+      }
+      return {
+        column: orderBy.column,
+        direction: orderBy.direction
+      };
+    });
+  }
+  readCursorColumnValue(entity, column2) {
+    const unqualifiedColumn = column2.split(".").at(-1) ?? column2;
+    return entity.get(unqualifiedColumn);
+  }
 };
 
 // src/model/runtimeSettings.ts
@@ -11577,12 +11757,16 @@ var DatabaseContext = class _DatabaseContext {
   async transaction(callback, options) {
     await this.initialize();
     this._assertValidOperationOptions(options);
+    this._assertValidTransactionOptions(options);
     this._throwIfAborted(options?.signal, "transaction");
     if (this._scope.kind === "root") {
       return this._runRootTransaction(callback, options);
     }
     return this._runNestedTransaction(callback, options);
   }
+  async writeTransaction(callback, options) {
+    return this.transaction(callback, this._resolveWriteTransactionOptions(options));
+  }
   async _runRootTransaction(callback, options) {
     const runWithinScope = this._adapter.runWithTransactionScope?.bind(this._adapter) ?? (async (runner) => runner());
     const entry = {
@@ -11931,6 +12115,29 @@ var DatabaseContext = class _DatabaseContext {
       throw new ConfigurationError("Database operation timeouts must be positive integers in milliseconds.");
     }
   }
+  _assertValidTransactionOptions(options) {
+    if (typeof options?.mode === "undefined") {
+      return;
+    }
+    if (options.mode !== "deferred" && options.mode !== "immediate" && options.mode !== "exclusive") {
+      throw new ConfigurationError("Database transaction mode must be one of deferred, immediate, or exclusive.");
+    }
+    if (!this._dialect.name.startsWith("sqlite")) {
+      throw new CapabilityError(`Transaction mode "${options.mode}" is only supported for SQLite connections.`);
+    }
+    if (this._scope.kind !== "root") {
+      throw new TransactionError("Transaction mode can only be set when starting a root transaction.");
+    }
+  }
+  _resolveWriteTransactionOptions(options) {
+    if (this._scope.kind !== "root" || !this._dialect.name.startsWith("sqlite")) {
+      return options;
+    }
+    return {
+      ...options,
+      mode: options?.mode ?? "immediate"
+    };
+  }
   _throwIfAborted(signal, action) {
     if (!signal?.aborted) {
       return;
@@ -12000,8 +12207,11 @@ var ConnectionManager = class {
       await connection.disconnect();
     }
   }
-  async transaction(callback, connectionName = this.defaultConnection) {
-    return this.connection(connectionName).transaction(callback);
+  async transaction(callback, connectionName = this.defaultConnection, options) {
+    return this.connection(connectionName).transaction(callback, options);
+  }
+  async writeTransaction(callback, connectionName = this.defaultConnection, options) {
+    return this.connection(connectionName).writeTransaction(callback, options);
   }
 };
 function createConnectionManager(options) {
@@ -12024,6 +12234,7 @@ function isModuleNotFoundError(error) {
 function dynamicImport(specifier) {
   return import(
     /* webpackIgnore: true */
+    /* @vite-ignore */
     specifier
   );
 }
@@ -12074,6 +12285,16 @@ var LazyDriverAdapter = class {
   isConnected() {
     return this.adapter?.isConnected() ?? this.connected;
   }
+  async ensureDatabaseExists() {
+    const adapter = await this.resolveAdapter();
+    if (typeof adapter.ensureDatabaseExists !== "function") {
+      return;
+    }
+    await adapter.ensureDatabaseExists();
+  }
+  isDatabaseMissingError(error) {
+    return this.adapter?.isDatabaseMissingError?.(error) ?? false;
+  }
   async runWithTransactionScope(callback) {
     const adapter = await this.resolveAdapter();
     if (typeof adapter.runWithTransactionScope !== "function") {
@@ -14491,6 +14712,7 @@ export {
   belongsToMany,
   binaryCast,
   clearGeneratedTables,
+  collectDatabaseQueryDependencies,
   column,
   compileDialectDefaultLiteral,
   configureDB,
@@ -14573,8 +14795,10 @@ export {
   ofMany,
   oldestMorphOne,
   oldestOfMany,
+  onDatabaseDependencyInvalidated,
   parseDatabaseDriver,
   queryCacheInternals,
+  recordDatabaseQueryDependencies,
   redactBindings,
   redactSql,
   registerGeneratedTables,
@@ -14585,6 +14809,7 @@ export {
   renderGeneratedSchemaPlaceholder,
   renderGeneratedSchemaRuntimeModule,
   resetDB,
+  resetDatabaseDependencyInvalidationListeners,
   resetDatabaseQueryCacheBridge,
   resetGlobalModelRegistry,
   resetMorphRegistry,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holo-js/db",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Holo-JS Framework - portable database, ORM, migrations, factories, and seeders",
   "type": "module",
   "license": "MIT",
@@ -28,9 +28,9 @@
     "uuid": "^12.0.0"
   },
   "peerDependencies": {
-    "@holo-js/db-mysql": "^0.1.9",
-    "@holo-js/db-postgres": "^0.1.9",
-    "@holo-js/db-sqlite": "^0.1.9"
+    "@holo-js/db-mysql": "^0.2.0",
+    "@holo-js/db-postgres": "^0.2.0",
+    "@holo-js/db-sqlite": "^0.2.0"
   },
   "peerDependenciesMeta": {
     "@holo-js/db-mysql": {
@@ -44,9 +44,9 @@
     }
   },
   "devDependencies": {
-    "@holo-js/db-mysql": "^0.1.9",
-    "@holo-js/db-postgres": "^0.1.9",
-    "@holo-js/db-sqlite": "^0.1.9",
+    "@holo-js/db-mysql": "^0.2.0",
+    "@holo-js/db-postgres": "^0.2.0",
+    "@holo-js/db-sqlite": "^0.2.0",
     "tsup": "^8.3.5",
     "typescript": "^5.7.2"
   }