@holo-js/core 0.1.1 → 0.1.3

package/dist/runtime/index.d.ts

@@ -1,5 +1,4 @@
 import { HoloConfigMap, LoadedHoloConfig, DotPath, ValueAtPath } from '@holo-js/config';
-import { QueueRuntimeBinding } from '@holo-js/queue';
 import { resolveRuntimeConnectionManagerOptions } from '@holo-js/db';
 export { RuntimeConfigInput, RuntimeConnectionConfig, RuntimeDatabaseConfig, RuntimeHoloConfig, SupportedDatabaseDriver, createAdapter, createDialect, createRuntimeConnectionOptions, createRuntimeLogger, isSupportedDatabaseDriver, parseDatabaseDriver, resolveRuntimeConnectionManagerOptions } from '@holo-js/db';
 
@@ -43,6 +42,36 @@ interface GeneratedListenerRegistryEntry {
     readonly eventNames: readonly string[];
     readonly exportName?: string;
 }
+interface GeneratedBroadcastRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+    readonly channels: readonly {
+        readonly type: 'public' | 'private' | 'presence';
+        readonly pattern: string;
+    }[];
+}
+interface GeneratedChannelRegistryEntry {
+    readonly sourcePath: string;
+    readonly pattern: string;
+    readonly exportName?: string;
+    readonly type: 'private' | 'presence';
+    readonly params: readonly string[];
+    readonly whispers: readonly string[];
+}
+interface GeneratedAuthorizationPolicyRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+    readonly target: string;
+    readonly classActions: readonly string[];
+    readonly recordActions: readonly string[];
+}
+interface GeneratedAuthorizationAbilityRegistryEntry {
+    readonly sourcePath: string;
+    readonly name: string;
+    readonly exportName?: string;
+}
 interface GeneratedProjectRegistry {
     readonly version: 1;
     readonly generatedAt: string;
@@ -54,6 +83,10 @@ interface GeneratedProjectRegistry {
         readonly jobs: string;
         readonly events: string;
         readonly listeners: string;
+        readonly broadcast: string;
+        readonly channels: string;
+        readonly authorizationPolicies: string;
+        readonly authorizationAbilities: string;
         readonly generatedSchema: string;
     };
     readonly models: readonly GeneratedModelRegistryEntry[];
@@ -63,12 +96,40 @@ interface GeneratedProjectRegistry {
     readonly jobs: readonly GeneratedJobRegistryEntry[];
     readonly events: readonly GeneratedEventRegistryEntry[];
     readonly listeners: readonly GeneratedListenerRegistryEntry[];
+    readonly broadcast: readonly GeneratedBroadcastRegistryEntry[];
+    readonly channels: readonly GeneratedChannelRegistryEntry[];
+    readonly authorizationPolicies: readonly GeneratedAuthorizationPolicyRegistryEntry[];
+    readonly authorizationAbilities: readonly GeneratedAuthorizationAbilityRegistryEntry[];
+}
+interface GeneratedBroadcastManifestEvent {
+    readonly name: string;
+    readonly channels: readonly {
+        readonly type: 'public' | 'private' | 'presence';
+        readonly pattern: string;
+    }[];
+}
+interface GeneratedBroadcastManifestChannel {
+    readonly name: string;
+    readonly pattern: string;
+    readonly type: 'private' | 'presence';
+    readonly params: readonly string[];
+    readonly whispers: readonly string[];
+    readonly member?: Readonly<Record<string, unknown>>;
+}
+interface GeneratedBroadcastManifest {
+    readonly version: 1;
+    readonly generatedAt: string;
+    readonly events: readonly GeneratedBroadcastManifestEvent[];
+    readonly channels: readonly GeneratedBroadcastManifestChannel[];
 }
 declare function normalizeLegacyGeneratedProjectRegistry(value: Record<string, unknown>): void;
 declare function isGeneratedProjectRegistry(value: unknown): value is GeneratedProjectRegistry;
 declare function resolveGeneratedProjectRegistryPath(projectRoot: string): string;
 declare function loadGeneratedProjectRegistry(projectRoot: string): Promise<GeneratedProjectRegistry | undefined>;
+declare function createGeneratedBroadcastManifest(registry: Pick<GeneratedProjectRegistry, 'generatedAt' | 'broadcast' | 'channels'>): GeneratedBroadcastManifest;
+declare function loadGeneratedBroadcastManifest(projectRoot: string): Promise<GeneratedBroadcastManifest | undefined>;
 declare const registryInternals: {
+    createGeneratedBroadcastManifest: typeof createGeneratedBroadcastManifest;
     isGeneratedProjectRegistry: typeof isGeneratedProjectRegistry;
     normalizeLegacyGeneratedProjectRegistry: typeof normalizeLegacyGeneratedProjectRegistry;
 };
@@ -78,12 +139,518 @@ type PortableRuntimeConfig<TCustom extends HoloConfigMap> = {
     readonly db: LoadedHoloConfig<TCustom>['database'];
     readonly queue: LoadedHoloConfig<TCustom>['queue'];
 };
+type CoreNotificationJsonPrimitive = string | number | boolean | null;
+type CoreNotificationJsonValue = CoreNotificationJsonPrimitive | readonly CoreNotificationJsonValue[] | {
+    readonly [key: string]: CoreNotificationJsonValue;
+};
+interface CoreNotificationDatabaseRoute {
+    readonly id: string | number;
+    readonly type: string;
+}
+interface CoreNotificationRecord<TData extends CoreNotificationJsonValue = CoreNotificationJsonValue> {
+    readonly id: string;
+    readonly type?: string;
+    readonly notifiableType: string;
+    readonly notifiableId: string | number;
+    readonly data: TData;
+    readonly readAt?: Date | null;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}
+interface CoreNotificationStore {
+    create(record: CoreNotificationRecord): Promise<void>;
+    list(notifiable: CoreNotificationDatabaseRoute): Promise<readonly CoreNotificationRecord[]>;
+    unread(notifiable: CoreNotificationDatabaseRoute): Promise<readonly CoreNotificationRecord[]>;
+    markAsRead(ids: readonly string[]): Promise<number>;
+    markAsUnread(ids: readonly string[]): Promise<number>;
+    delete(ids: readonly string[]): Promise<number>;
+}
+interface HoloSessionRuntimeBinding {
+    create(input?: {
+        readonly store?: string;
+        readonly data?: Readonly<Record<string, unknown>>;
+        readonly id?: string;
+    }): Promise<unknown>;
+    write(record: unknown): Promise<unknown>;
+    read(sessionId: string, options?: {
+        readonly store?: string;
+    }): Promise<unknown | null>;
+    rotate(sessionId: string, options?: {
+        readonly store?: string;
+        readonly newId?: string;
+    }): Promise<unknown>;
+    invalidate(sessionId: string, options?: {
+        readonly store?: string;
+    }): Promise<void>;
+    touch(sessionId: string, options?: {
+        readonly store?: string;
+    }): Promise<unknown | null>;
+    issueRememberMeToken(sessionId: string, options?: {
+        readonly store?: string;
+    }): Promise<string>;
+    consumeRememberMeToken(token: string, options?: {
+        readonly store?: string;
+    }): Promise<unknown | null>;
+    cookie(name: string, value: string, options?: Record<string, unknown>): string;
+    sessionCookie(value: string, options?: Record<string, unknown>): string;
+    rememberMeCookie(value: string, options?: Record<string, unknown>): string;
+}
+interface HoloAuthRuntimeBinding {
+    check(): Promise<boolean>;
+    user(): Promise<unknown | null>;
+    refreshUser(): Promise<unknown | null>;
+    id(): Promise<string | number | null>;
+    currentAccessToken(): Promise<unknown | null>;
+    hashPassword(password: string): Promise<string>;
+    verifyPassword(password: string, digest: string): Promise<boolean>;
+    needsPasswordRehash(digest: string): Promise<boolean>;
+    login(credentials: Readonly<Record<string, unknown>> & {
+        readonly password: string;
+        readonly remember?: boolean;
+    }): Promise<{
+        readonly guard: string;
+        readonly user: unknown;
+        readonly sessionId: string;
+        readonly rememberToken?: string;
+        readonly cookies: readonly string[];
+    }>;
+    loginUsing(user: unknown, options?: {
+        readonly remember?: boolean;
+    }): Promise<{
+        readonly guard: string;
+        readonly user: unknown;
+        readonly sessionId: string;
+        readonly rememberToken?: string;
+        readonly cookies: readonly string[];
+    }>;
+    loginUsingId(userId: string | number, options?: {
+        readonly remember?: boolean;
+    }): Promise<{
+        readonly guard: string;
+        readonly user: unknown;
+        readonly sessionId: string;
+        readonly rememberToken?: string;
+        readonly cookies: readonly string[];
+    }>;
+    impersonate(user: unknown, options?: {
+        readonly remember?: boolean;
+        readonly actorGuard?: string;
+    }): Promise<{
+        readonly guard: string;
+        readonly user: unknown;
+        readonly sessionId: string;
+        readonly rememberToken?: string;
+        readonly cookies: readonly string[];
+    }>;
+    impersonateById(userId: string | number, options?: {
+        readonly remember?: boolean;
+        readonly actorGuard?: string;
+    }): Promise<{
+        readonly guard: string;
+        readonly user: unknown;
+        readonly sessionId: string;
+        readonly rememberToken?: string;
+        readonly cookies: readonly string[];
+    }>;
+    impersonation(): Promise<unknown | null>;
+    stopImpersonating(): Promise<unknown | null>;
+    logout(): Promise<{
+        readonly guard: string;
+        readonly cookies: readonly string[];
+    }>;
+    register(input: Readonly<Record<string, unknown>> & {
+        readonly password: string;
+        readonly passwordConfirmation: string;
+        readonly remember?: boolean;
+    }): Promise<unknown>;
+    logoutAll(guardName?: string): Promise<readonly {
+        readonly guard: string;
+        readonly cookies: readonly string[];
+    }[]>;
+    guard(name: string): {
+        check(): Promise<boolean>;
+        user(): Promise<unknown | null>;
+        refreshUser(): Promise<unknown | null>;
+        id(): Promise<string | number | null>;
+        currentAccessToken(): Promise<unknown | null>;
+        login(credentials: Readonly<Record<string, unknown>> & {
+            readonly password: string;
+            readonly remember?: boolean;
+        }): Promise<{
+            readonly guard: string;
+            readonly user: unknown;
+            readonly sessionId: string;
+            readonly rememberToken?: string;
+            readonly cookies: readonly string[];
+        }>;
+        loginUsing(user: unknown, options?: {
+            readonly remember?: boolean;
+        }): Promise<{
+            readonly guard: string;
+            readonly user: unknown;
+            readonly sessionId: string;
+            readonly rememberToken?: string;
+            readonly cookies: readonly string[];
+        }>;
+        loginUsingId(userId: string | number, options?: {
+            readonly remember?: boolean;
+        }): Promise<{
+            readonly guard: string;
+            readonly user: unknown;
+            readonly sessionId: string;
+            readonly rememberToken?: string;
+            readonly cookies: readonly string[];
+        }>;
+        impersonate(user: unknown, options?: {
+            readonly remember?: boolean;
+            readonly actorGuard?: string;
+        }): Promise<{
+            readonly guard: string;
+            readonly user: unknown;
+            readonly sessionId: string;
+            readonly rememberToken?: string;
+            readonly cookies: readonly string[];
+        }>;
+        impersonateById(userId: string | number, options?: {
+            readonly remember?: boolean;
+            readonly actorGuard?: string;
+        }): Promise<{
+            readonly guard: string;
+            readonly user: unknown;
+            readonly sessionId: string;
+            readonly rememberToken?: string;
+            readonly cookies: readonly string[];
+        }>;
+        impersonation(): Promise<unknown | null>;
+        stopImpersonating(): Promise<unknown | null>;
+        logout(): Promise<{
+            readonly guard: string;
+            readonly cookies: readonly string[];
+        }>;
+    };
+    tokens: {
+        create(user: unknown, options: {
+            readonly name: string;
+            readonly abilities?: readonly string[];
+            readonly expiresAt?: Date | null;
+            readonly guard?: string;
+        }): Promise<unknown>;
+        list(user: unknown, options?: {
+            readonly guard?: string;
+        }): Promise<readonly unknown[]>;
+        revoke(options?: {
+            readonly guard?: string;
+        }): Promise<void>;
+        revokeAll(user: unknown, options?: {
+            readonly guard?: string;
+        }): Promise<number>;
+        authenticate(plainTextToken: string): Promise<unknown | null>;
+        can(token: string, ability: string): Promise<boolean>;
+    };
+    verification: {
+        create(user: unknown, options?: {
+            readonly guard?: string;
+            readonly expiresAt?: Date;
+        }): Promise<unknown>;
+        consume(plainTextToken: string): Promise<unknown>;
+    };
+    passwords: {
+        request(email: string, options?: {
+            readonly broker?: string;
+            readonly expiresAt?: Date;
+        }): Promise<void>;
+        consume(input: {
+            readonly token: string;
+            readonly password: string;
+            readonly passwordConfirmation: string;
+        }): Promise<unknown>;
+    };
+}
+interface HoloQueueRuntimeBinding {
+    readonly config: LoadedHoloConfig['queue'];
+    readonly drivers: ReadonlyMap<string, HoloQueueDriverBinding>;
+}
+interface HoloQueueDriverBinding {
+    readonly name: string;
+    readonly driver: string;
+    readonly mode: 'async' | 'sync';
+}
+interface HoloServerViewRenderInput {
+    readonly view: string;
+    readonly props?: Readonly<Record<string, unknown>>;
+}
+type HoloServerViewRenderer = (input: HoloServerViewRenderInput) => string | Promise<string>;
+type QueueModule = {
+    configureQueueRuntime(options: {
+        config: LoadedHoloConfig['queue'];
+        redisConfig?: LoadedHoloConfig['redis'];
+    } & Record<string, unknown>): void;
+    getRegisteredQueueJob(name: string): {
+        sourcePath?: string;
+    } | undefined;
+    getQueueRuntime(): HoloQueueRuntimeBinding;
+    isQueueJobDefinition(value: unknown): boolean;
+    normalizeQueueJobDefinition(value: unknown): NormalizedQueueJobDefinition;
+    registerQueueJob(definition: NormalizedQueueJobDefinition, options: {
+        name: string;
+        sourcePath?: string;
+        replaceExisting?: boolean;
+    }): void;
+    shutdownQueueRuntime(): Promise<void>;
+    unregisterQueueJob(name: string): void;
+};
+type SessionModule = {
+    configureSessionRuntime(options?: {
+        readonly config: LoadedHoloConfig['session'];
+        readonly stores: Readonly<Record<string, {
+            read(sessionId: string): Promise<unknown | null>;
+            write(record: unknown): Promise<void>;
+            delete(sessionId: string): Promise<void>;
+        }>>;
+    }): void;
+    createDatabaseSessionStore(adapter: {
+        read(sessionId: string): Promise<unknown | null>;
+        write(record: unknown): Promise<void>;
+        delete(sessionId: string): Promise<void>;
+    }): {
+        read(sessionId: string): Promise<unknown | null>;
+        write(record: unknown): Promise<void>;
+        delete(sessionId: string): Promise<void>;
+    };
+    createFileSessionStore(root: string): {
+        read(sessionId: string): Promise<unknown | null>;
+        write(record: unknown): Promise<void>;
+        delete(sessionId: string): Promise<void>;
+    };
+    createRedisSessionStore(adapter: SessionRedisAdapter): {
+        read(sessionId: string): Promise<unknown | null>;
+        write(record: unknown): Promise<void>;
+        delete(sessionId: string): Promise<void>;
+    };
+    getSessionRuntime(): HoloSessionRuntimeBinding;
+    resetSessionRuntime(): void;
+};
+type SessionRedisAdapter = {
+    connect?(): Promise<void>;
+    disconnect?(): Promise<void>;
+    get(sessionId: string): Promise<unknown | null>;
+    set(record: unknown): Promise<void>;
+    del(sessionId: string): Promise<void>;
+    close?(): Promise<void>;
+};
+type NotificationsModule = {
+    configureNotificationsRuntime(options?: {
+        readonly config: LoadedHoloConfig['notifications'];
+        readonly mailer?: {
+            send(message: {
+                readonly subject: string;
+                readonly greeting?: string;
+                readonly lines?: readonly string[];
+                readonly action?: {
+                    readonly label: string;
+                    readonly url: string;
+                };
+                readonly html?: string;
+                readonly text?: string;
+                readonly metadata?: Readonly<Record<string, unknown>>;
+            }, context: {
+                readonly route?: string | {
+                    readonly email: string;
+                    readonly name?: string;
+                };
+            }): Promise<void>;
+        };
+        readonly store?: {
+            create(record: unknown): Promise<void>;
+            list(notifiable: {
+                id: string | number;
+                type: string;
+            }): Promise<readonly unknown[]>;
+            unread(notifiable: {
+                id: string | number;
+                type: string;
+            }): Promise<readonly unknown[]>;
+            markAsRead(ids: readonly string[]): Promise<number>;
+            markAsUnread(ids: readonly string[]): Promise<number>;
+            delete(ids: readonly string[]): Promise<number>;
+        };
+        readonly broadcaster?: ReturnType<typeof createCoreNotificationBroadcaster>;
+    }): void;
+    getNotificationsRuntimeBindings(): {
+        readonly mailer?: {
+            send(message: {
+                readonly subject: string;
+            }, context: {
+                readonly route?: string | {
+                    readonly email: string;
+                    readonly name?: string;
+                };
+            }): Promise<void>;
+        };
+        readonly broadcaster?: {
+            send(message: unknown, context: {
+                readonly channel: string;
+                readonly route?: unknown;
+            }): Promise<void>;
+        };
+        readonly store?: {
+            create(record: unknown): Promise<void>;
+            list(notifiable: {
+                id: string | number;
+                type: string;
+            }): Promise<readonly unknown[]>;
+            unread(notifiable: {
+                id: string | number;
+                type: string;
+            }): Promise<readonly unknown[]>;
+            markAsRead(ids: readonly string[]): Promise<number>;
+            markAsUnread(ids: readonly string[]): Promise<number>;
+            delete(ids: readonly string[]): Promise<number>;
+        };
+    };
+    defineNotification(definition: {
+        readonly type?: string;
+        via(notifiable: unknown, context: {
+            readonly anonymous: boolean;
+        }): readonly string[];
+        readonly build: Readonly<Record<string, (notifiable: unknown, context: {
+            readonly channel: string;
+            readonly anonymous: boolean;
+        }) => unknown>>;
+    }): unknown;
+    notify(notifiable: unknown, notification: unknown): PromiseLike<unknown>;
+    notifyUsing(): {
+        channel(channel: 'email', route: string | {
+            readonly email: string;
+            readonly name?: string;
+        }): {
+            notify(notification: unknown): PromiseLike<unknown>;
+        };
+    };
+    resetNotificationsRuntime(): void;
+};
+type BroadcastModule = {
+    configureBroadcastRuntime(options?: {
+        readonly config: LoadedHoloConfig['broadcast'];
+        readonly publish?: (input: {
+            readonly connection: string;
+            readonly event: string;
+            readonly channels: readonly string[];
+            readonly payload: Readonly<Record<string, unknown>>;
+            readonly socketId?: string;
+        }, context: {
+            readonly connection: string;
+            readonly driver: string;
+            readonly queued: boolean;
+            readonly delayed: boolean;
+        }) => Promise<unknown> | unknown;
+    }): void;
+    getBroadcastRuntimeBindings(): {
+        readonly config?: LoadedHoloConfig['broadcast'];
+        readonly publish?: (input: {
+            readonly connection: string;
+            readonly event: string;
+            readonly channels: readonly string[];
+            readonly payload: Readonly<Record<string, unknown>>;
+            readonly socketId?: string;
+        }, context: {
+            readonly connection: string;
+            readonly driver: string;
+            readonly queued: boolean;
+            readonly delayed: boolean;
+        }) => Promise<unknown> | unknown;
+    };
+    broadcastRaw(input: {
+        readonly connection?: string;
+        readonly event: string;
+        readonly channels: readonly string[];
+        readonly payload: Readonly<Record<string, unknown>>;
+        readonly socketId?: string;
+    }): PromiseLike<unknown>;
+    resetBroadcastRuntime(): void;
+};
+type MailModule = {
+    configureMailRuntime(options?: {
+        readonly config: LoadedHoloConfig['mail'];
+        readonly renderView?: HoloServerViewRenderer;
+    }): void;
+    getMailRuntimeBindings(): {
+        readonly send?: unknown;
+        readonly preview?: unknown;
+        readonly renderPreview?: unknown;
+        readonly renderView?: HoloServerViewRenderer;
+    };
+    sendMail(mail: {
+        readonly mailer?: string;
+        readonly from?: unknown;
+        readonly replyTo?: unknown;
+        readonly to: unknown;
+        readonly cc?: unknown;
+        readonly bcc?: unknown;
+        readonly subject: string;
+        readonly text?: string;
+        readonly html?: string;
+        readonly markdown?: string;
+        readonly render?: {
+            readonly view: string;
+            readonly props?: Readonly<Record<string, unknown>>;
+        };
+        readonly markdownWrapper?: string;
+        readonly attachments?: readonly unknown[];
+        readonly headers?: Readonly<Record<string, string>>;
+        readonly tags?: readonly string[];
+        readonly metadata?: Readonly<Record<string, unknown>>;
+        readonly priority?: 'high' | 'normal' | 'low';
+        readonly queue?: boolean | {
+            readonly queued?: boolean;
+            readonly connection?: string;
+            readonly queue?: string;
+            readonly afterCommit?: boolean;
+        };
+        readonly delay?: number | Date;
+    }): PromiseLike<unknown>;
+    resetMailRuntime(): void;
+};
+type AuthorizationModule = {
+    isAuthorizationPolicyDefinition(value: unknown): boolean;
+    isAuthorizationAbilityDefinition(value: unknown): boolean;
+    authorizationInternals: {
+        getAuthorizationRuntimeState(): {
+            policiesByName: Map<string, unknown>;
+            abilitiesByName: Map<string, unknown>;
+        };
+        getAuthorizationAuthIntegration(): {
+            hasGuard(guardName: string): boolean;
+            resolveDefaultActor(): Promise<object | null> | object | null;
+            resolveGuardActor(guardName: string): Promise<object | null> | object | null;
+        };
+        registerPolicyDefinition?(definition: unknown): unknown;
+        registerAbilityDefinition?(definition: unknown): unknown;
+        configureAuthorizationAuthIntegration(options?: {
+            hasGuard(guardName: string): boolean;
+            resolveDefaultActor(): Promise<object | null> | object | null;
+            resolveGuardActor(guardName: string): Promise<object | null> | object | null;
+        }): void;
+        resetAuthorizationAuthIntegration(): void;
+        resetAuthorizationRuntimeState(): void;
+        unregisterPolicyDefinition(name: string): void;
+        unregisterAbilityDefinition(name: string): void;
+    };
+};
 type PortableConnectionManager = ReturnType<typeof resolveRuntimeConnectionManagerOptions>;
+type NormalizedQueueJobDefinition = {
+    readonly connection?: string;
+    readonly queue?: string;
+    readonly tries?: number;
+    readonly backoff?: number | readonly number[];
+    readonly timeout?: number;
+};
 interface CreateHoloOptions {
     readonly envName?: string;
     readonly preferCache?: boolean;
     readonly processEnv?: NodeJS.ProcessEnv;
     readonly registerProjectQueueJobs?: boolean;
+    readonly renderView?: HoloServerViewRenderer;
 }
 interface HoloRuntime<TCustom extends HoloConfigMap = HoloConfigMap> {
     readonly projectRoot: string;
@@ -91,7 +658,9 @@ interface HoloRuntime<TCustom extends HoloConfigMap = HoloConfigMap> {
     readonly registry?: GeneratedProjectRegistry;
     readonly manager: PortableConnectionManager;
     readonly runtimeConfig: PortableRuntimeConfig<TCustom>;
-    readonly queue: QueueRuntimeBinding;
+    readonly queue: HoloQueueRuntimeBinding;
+    readonly session?: HoloSessionRuntimeBinding;
+    readonly auth?: HoloAuthRuntimeBinding;
     readonly initialized: boolean;
     initialize(): Promise<void>;
     shutdown(): Promise<void>;
@@ -99,6 +668,211 @@ interface HoloRuntime<TCustom extends HoloConfigMap = HoloConfigMap> {
     useConfig<TPath extends DotPath<RuntimeConfigRegistry<TCustom>>>(path: TPath): ValueAtPath<RuntimeConfigRegistry<TCustom>, TPath>;
     config<TPath extends DotPath<RuntimeConfigRegistry<TCustom>>>(path: TPath): ValueAtPath<RuntimeConfigRegistry<TCustom>, TPath>;
 }
+declare function configureHoloRenderingRuntime(bindings?: {
+    readonly renderView?: HoloServerViewRenderer;
+}): void;
+declare function resetHoloRenderingRuntime(): void;
+declare function importOptionalModule<TModule>(specifier: string, options?: {
+    readonly projectRoot?: string;
+}): Promise<TModule | undefined>;
+declare function bindAuthRuntimeToContext(runtime: HoloAuthRuntimeBinding, authContext: {
+    activate(): void;
+}): HoloAuthRuntimeBinding;
+declare function loadAuthorizationModule(required?: boolean): Promise<AuthorizationModule | undefined>;
+declare function resolveAuthorizationDefinitionExport(moduleValue: unknown, exportName: string | undefined, matcher: (value: unknown) => boolean): unknown | undefined;
+declare function normalizeNotificationRecordFromRow(row: Record<string, unknown>): CoreNotificationRecord<CoreNotificationJsonValue>;
+declare function serializeNotificationRecordForRow(record: {
+    readonly id: string;
+    readonly type?: string;
+    readonly notifiableType: string;
+    readonly notifiableId: string | number;
+    readonly data: unknown;
+    readonly readAt?: Date | null;
+    readonly createdAt: Date;
+    readonly updatedAt: Date;
+}): Record<string, unknown>;
+declare function markProviderUser<T>(value: T, providerName: string): T;
+declare function createCoreSessionStores<TCustom extends HoloConfigMap>(projectRoot: string, loadedConfig: LoadedHoloConfig<TCustom>, sessionModule: SessionModule): Promise<Readonly<Record<string, {
+    read(sessionId: string): Promise<unknown | null>;
+    write(record: unknown): Promise<void>;
+    delete(sessionId: string): Promise<void>;
+}>>>;
+declare function createCoreNotificationStore<TCustom extends HoloConfigMap>(loadedConfig: LoadedHoloConfig<TCustom>): CoreNotificationStore;
+declare function createAuthNotificationsDeliveryHook(notificationsModule: NotificationsModule): {
+    sendEmailVerification(input: {
+        readonly provider: string;
+        readonly user: unknown;
+        readonly email: string;
+        readonly token: {
+            readonly id: string;
+            readonly plainTextToken: string;
+            readonly expiresAt: Date;
+        };
+    }): Promise<void>;
+    sendPasswordReset(input: {
+        readonly provider: string;
+        readonly email: string;
+        readonly token: {
+            readonly id: string;
+            readonly plainTextToken: string;
+            readonly expiresAt: Date;
+        };
+    }): Promise<void>;
+};
+declare function createCoreNotificationBroadcaster(broadcastModule: BroadcastModule): {
+    send(message: {
+        readonly event?: string;
+        readonly data: unknown;
+    }, context: {
+        readonly route?: unknown;
+        readonly notificationType?: string;
+    }): Promise<void>;
+};
+declare function createNotificationMailText(message: {
+    readonly greeting?: string;
+    readonly lines?: readonly string[];
+    readonly action?: {
+        readonly label: string;
+        readonly url: string;
+    };
+}): string | undefined;
+declare function createCoreNotificationMailSender(mailModule: MailModule): {
+    send(message: {
+        readonly subject: string;
+        readonly greeting?: string;
+        readonly lines?: readonly string[];
+        readonly action?: {
+            readonly label: string;
+            readonly url: string;
+        };
+        readonly html?: string;
+        readonly text?: string;
+        readonly metadata?: Readonly<Record<string, unknown>>;
+    }, context: {
+        readonly route?: string | {
+            readonly email: string;
+            readonly name?: string;
+        };
+    }): Promise<void>;
+};
+declare function createAuthMailDeliveryHook(mailModule: MailModule): {
+    sendEmailVerification(input: {
+        readonly provider: string;
+        readonly user: unknown;
+        readonly email: string;
+        readonly token: {
+            readonly id: string;
+            readonly plainTextToken: string;
+            readonly expiresAt: Date;
+        };
+    }): Promise<void>;
+    sendPasswordReset(input: {
+        readonly provider: string;
+        readonly email: string;
+        readonly token: {
+            readonly id: string;
+            readonly plainTextToken: string;
+            readonly expiresAt: Date;
+        };
+    }): Promise<void>;
+};
+declare function loadConfiguredSocialProviders<TCustom extends HoloConfigMap>(projectRootOrLoadedConfig: string | LoadedHoloConfig<TCustom>, maybeLoadedConfig?: LoadedHoloConfig<TCustom>): Promise<Readonly<Record<string, unknown>>>;
+declare function normalizeDateValue(value: unknown): Date;
+declare function normalizeJsonValue(value: unknown): unknown;
+declare function normalizeEmailVerificationTokenRecord(row: Record<string, unknown>): {
+    readonly id: string;
+    readonly provider: string;
+    readonly userId: string | number;
+    readonly email: string;
+    readonly tokenHash: string;
+    readonly createdAt: Date;
+    readonly expiresAt: Date;
+};
+declare function normalizePasswordResetTokenRecord(row: Record<string, unknown>): {
+    readonly id: string;
+    readonly provider: string;
+    readonly email: string;
+    readonly table?: string;
+    readonly tokenHash: string;
+    readonly createdAt: Date;
+    readonly expiresAt: Date;
+};
+declare function createCoreSocialBindings<TCustom extends HoloConfigMap>(projectRootOrLoadedConfig: string | LoadedHoloConfig<TCustom>, loadedConfigOrSessionModule: LoadedHoloConfig<TCustom> | SessionModule, maybeSessionModule?: SessionModule): Promise<{
+    readonly providers: Readonly<Record<string, unknown>>;
+    readonly stateStore: {
+        create(record: {
+            readonly provider: string;
+            readonly state: string;
+            readonly codeVerifier: string;
+            readonly guard: string;
+            readonly createdAt: Date;
+        }): Promise<void>;
+        read(provider: string, state: string): Promise<{
+            readonly provider: string;
+            readonly state: string;
+            readonly codeVerifier: string;
+            readonly guard: string;
+            readonly createdAt: Date;
+        } | null>;
+        delete(provider: string, state: string): Promise<void>;
+    };
+    readonly identityStore: {
+        findByProviderUserId(provider: string, providerUserId: string): Promise<unknown | null>;
+        save(record: unknown): Promise<void>;
+    };
+}>;
+declare function fromHostedIdentityProviderValue(namespace: string, provider: string): string;
+declare function createCoreHostedIdentityStore(namespace: string): {
+    findByProviderUserId(provider: string, providerUserId: string): Promise<unknown | null>;
+    findByUserId(provider: string, authProvider: string, userId: string | number): Promise<unknown | null>;
+    save(record: unknown): Promise<void>;
+};
+declare function createCoreAuthStores<TCustom extends HoloConfigMap>(loadedConfig: LoadedHoloConfig<TCustom>): {
+    readonly tokens: {
+        create(record: unknown): Promise<void>;
+        findById(id: string): Promise<unknown | null>;
+        listByUserId(provider: string, userId: string | number): Promise<readonly unknown[]>;
+        update(record: unknown): Promise<void>;
+        delete(id: string): Promise<void>;
+        deleteByUserId(provider: string, userId: string | number): Promise<number>;
+    };
+    readonly emailVerificationTokens: {
+        create(record: unknown): Promise<void>;
+        findById(id: string): Promise<unknown | null>;
+        delete(id: string): Promise<void>;
+        deleteByUserId(provider: string, userId: string | number): Promise<number>;
+    };
+    readonly passwordResetTokens: {
+        create(record: unknown): Promise<void>;
+        findById(id: string): Promise<unknown | null>;
+        findLatestByEmail(provider: string, email: string, options?: {
+            readonly table?: string;
+        }): Promise<unknown | null>;
+        delete(id: string, options?: {
+            readonly table?: string;
+        }): Promise<void>;
+        deleteByEmail(provider: string, email: string, options?: {
+            readonly table?: string;
+        }): Promise<number>;
+    };
+};
+declare function createCoreAuthProviders<TCustom extends HoloConfigMap>(projectRoot: string, loadedConfig: LoadedHoloConfig<TCustom>): Promise<Readonly<Record<string, unknown>>>;
+declare function registerProjectAuthorizationDefinitions(projectRoot: string, registry: GeneratedProjectRegistry | undefined, authorizationModule: AuthorizationModule | undefined): Promise<{
+    readonly policyNames: readonly string[];
+    readonly abilityNames: readonly string[];
+}>;
+declare function unregisterProjectAuthorizationDefinitions(authorizationModule: AuthorizationModule | undefined, policyNames: readonly string[], abilityNames: readonly string[]): void;
+declare function reconfigureOptionalHoloSubsystems<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, loadedConfig: LoadedHoloConfig<TCustom>, options?: {
+    readonly renderView?: HoloServerViewRenderer;
+}): Promise<{
+    readonly queueModule?: QueueModule;
+    readonly session?: HoloSessionRuntimeBinding;
+    readonly auth?: HoloAuthRuntimeBinding;
+    readonly authContext?: {
+        activate(): void;
+    };
+}>;
+declare function resetOptionalHoloSubsystems(): Promise<void>;
 declare function createHolo<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloRuntime<TCustom>>;
 declare function initializeHolo<TCustom extends HoloConfigMap = HoloConfigMap>(projectRoot: string, options?: CreateHoloOptions): Promise<HoloRuntime<TCustom>>;
 declare function peekHolo<TCustom extends HoloConfigMap = HoloConfigMap>(): HoloRuntime<TCustom> | undefined;
@@ -108,8 +882,36 @@ declare function resetHoloRuntime(): Promise<void>;
 declare function getConfigValue(path: string): unknown;
 declare function getConfigSection(key: string): unknown;
 declare const holoRuntimeInternals: {
+    createAuthMailDeliveryHook: typeof createAuthMailDeliveryHook;
+    createAuthNotificationsDeliveryHook: typeof createAuthNotificationsDeliveryHook;
+    createCoreNotificationBroadcaster: typeof createCoreNotificationBroadcaster;
+    createCoreNotificationMailSender: typeof createCoreNotificationMailSender;
+    bindAuthRuntimeToContext: typeof bindAuthRuntimeToContext;
+    createCoreAuthProviders: typeof createCoreAuthProviders;
+    createCoreAuthStores: typeof createCoreAuthStores;
+    createCoreHostedIdentityStore: typeof createCoreHostedIdentityStore;
+    createCoreNotificationStore: typeof createCoreNotificationStore;
+    createNotificationMailText: typeof createNotificationMailText;
+    createCoreSessionStores: typeof createCoreSessionStores;
+    registerProjectAuthorizationDefinitions: typeof registerProjectAuthorizationDefinitions;
+    unregisterProjectAuthorizationDefinitions: typeof unregisterProjectAuthorizationDefinitions;
+    resolveAuthorizationDefinitionExport: typeof resolveAuthorizationDefinitionExport;
+    fromHostedIdentityProviderValue: typeof fromHostedIdentityProviderValue;
     getConfigSection: typeof getConfigSection;
     getConfigValue: typeof getConfigValue;
+    createCoreSocialBindings: typeof createCoreSocialBindings;
+    normalizeNotificationRecordFromRow: typeof normalizeNotificationRecordFromRow;
+    loadConfiguredSocialProviders: typeof loadConfiguredSocialProviders;
+    loadAuthorizationModule: typeof loadAuthorizationModule;
+    markProviderUser: typeof markProviderUser;
+    normalizeDateValue: typeof normalizeDateValue;
+    normalizeEmailVerificationTokenRecord: typeof normalizeEmailVerificationTokenRecord;
+    normalizeJsonValue: typeof normalizeJsonValue;
+    normalizePasswordResetTokenRecord: typeof normalizePasswordResetTokenRecord;
+    serializeNotificationRecordForRow: typeof serializeNotificationRecordForRow;
+    moduleInternals: {
+        importOptionalModule: typeof importOptionalModule;
+    };
 };
 
-export { type CreateHoloOptions, type GeneratedCommandRegistryEntry, type GeneratedEventRegistryEntry, type GeneratedJobRegistryEntry, type GeneratedListenerRegistryEntry, type GeneratedMigrationRegistryEntry, type GeneratedModelRegistryEntry, type GeneratedProjectRegistry, type GeneratedSeederRegistryEntry, type HoloRuntime, createHolo, ensureHolo, getHolo, holoRuntimeInternals, initializeHolo, loadGeneratedProjectRegistry, peekHolo, registryInternals, resetHoloRuntime, resolveGeneratedProjectRegistryPath };
+export { type CreateHoloOptions, type GeneratedAuthorizationAbilityRegistryEntry, type GeneratedAuthorizationPolicyRegistryEntry, type GeneratedBroadcastManifest, type GeneratedBroadcastManifestChannel, type GeneratedBroadcastManifestEvent, type GeneratedBroadcastRegistryEntry, type GeneratedChannelRegistryEntry, type GeneratedCommandRegistryEntry, type GeneratedEventRegistryEntry, type GeneratedJobRegistryEntry, type GeneratedListenerRegistryEntry, type GeneratedMigrationRegistryEntry, type GeneratedModelRegistryEntry, type GeneratedProjectRegistry, type GeneratedSeederRegistryEntry, type HoloAuthRuntimeBinding, type HoloQueueDriverBinding, type HoloQueueRuntimeBinding, type HoloRuntime, type HoloServerViewRenderInput, type HoloServerViewRenderer, type HoloSessionRuntimeBinding, configureHoloRenderingRuntime, createGeneratedBroadcastManifest, createHolo, ensureHolo, getHolo, holoRuntimeInternals, initializeHolo, loadGeneratedBroadcastManifest, loadGeneratedProjectRegistry, peekHolo, reconfigureOptionalHoloSubsystems, registryInternals, resetHoloRenderingRuntime, resetHoloRuntime, resetOptionalHoloSubsystems, resolveGeneratedProjectRegistryPath };