@getstrata/bootstrap 0.2.3 → 0.2.5

package/dist/bootstrap/app.d.ts

@@ -0,0 +1,7 @@
+declare class App {
+    private server?;
+    serve(): void;
+    stop(force?: boolean): void;
+    private resolvePort;
+}
+export default App;

package/dist/bootstrap/createRoutes.d.ts

@@ -0,0 +1,3 @@
+import type { AppDependencies, AppRouteMap } from "./contracts";
+declare function createRoutes(dependencies: AppDependencies): AppRouteMap;
+export { createRoutes };

package/dist/bootstrap/createSpaRoutes.d.ts

@@ -0,0 +1,5 @@
+import type { AppDependencies, AppRouteMap } from "./contracts";
+declare const SPA_DIST_DIRECTORY: string;
+declare function createSpaRoutes(_dependencies: AppDependencies): AppRouteMap;
+declare function mergeSpaRoutes(dependencies: AppDependencies, routes: AppRouteMap): AppRouteMap;
+export { createSpaRoutes, mergeSpaRoutes, SPA_DIST_DIRECTORY };

package/dist/bootstrap/dependencies.d.ts

@@ -0,0 +1,4 @@
+import { createAppContext } from "./context";
+declare function createAppDependencies(): import("./contracts").AppDependencies;
+export type { AppContext, AppDependencies } from "./contracts";
+export { createAppContext, createAppDependencies };

package/dist/bootstrap/health.d.ts

@@ -0,0 +1,8 @@
+import type { AppDependencies } from "./contracts";
+declare function checkDatabase(): Promise<boolean>;
+declare function checkRedis(redisUrl: string): Promise<boolean>;
+declare function createHealthRoutes(dependencies: AppDependencies): {
+    "/health": () => Promise<Response>;
+    "/ready": () => Promise<Response>;
+};
+export { checkDatabase, checkRedis, createHealthRoutes };

package/dist/bootstrap/metricsRoutes.d.ts

@@ -0,0 +1,4 @@
+declare function createMetricsRoutes(): {
+    "/metrics": () => Promise<Response>;
+};
+export { createMetricsRoutes };

package/dist/bootstrap/middleware.d.ts

@@ -0,0 +1,4 @@
+import { type Middleware } from "../core/http/middleware";
+import type { AppDependencies } from "./contracts";
+declare function createDefaultMiddleware(dependencies: AppDependencies): Middleware[];
+export { createDefaultMiddleware };

package/dist/bootstrap/public-api.d.ts

@@ -13,4 +13,4 @@ export { createWebRoutes, mergeWebRoutes } from "./createWebRoutes.ts";
 export { createHttpKernel, type HttpKernel, type MiddlewareGroupName } from "./httpKernel.ts";
 export { prefixRouteMap } from "./prefixRouteMap.ts";
 export { coreProviders } from "./providers/index.ts";
-export { CookieSessionStore, createCsrfProtection, createWebServer, type ParsedForm, parseFormBody, type SessionUser, slugify, type WebServerOptions, } from "./web/index.ts";
+export { CookieSessionStore, createCsrfProtection, createRouteKernel, createWebServer, type ParsedForm, parseFormBody, routeParams, type SessionUser, slugify, toRouteRequest, type WebServerOptions, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./web/index.ts";

package/dist/bootstrap/routes.d.ts

@@ -0,0 +1,2 @@
+declare const routes: import("./contracts").AppRouteMap;
+export { routes };

package/dist/bootstrap/scimRoutes.d.ts

@@ -0,0 +1,24 @@
+import type { RouteHandler } from "../core/http/middleware";
+import type { AppDependencies } from "./contracts";
+declare function createScimRoutes(dependencies: AppDependencies): {
+    "/scim/v2/ServiceProviderConfig": {
+        GET: RouteHandler;
+    };
+    "/scim/v2/Users": {
+        GET: RouteHandler;
+        POST: RouteHandler;
+    };
+    "/scim/v2/Users/:id": {
+        GET: RouteHandler;
+        PATCH: RouteHandler;
+        DELETE: RouteHandler;
+    };
+    "/scim/v2/Groups": {
+        GET: RouteHandler;
+    };
+    "/scim/v2/Groups/:id": {
+        GET: RouteHandler;
+        PATCH: RouteHandler;
+    };
+};
+export { createScimRoutes };

package/dist/bootstrap/server.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bootstrap/web/index.d.ts

@@ -2,6 +2,7 @@
  * Web-focused bootstrap utilities for sibling apps (getstrata, marketing sites).
  */
 export { createCsrfProtection, type ParsedForm, parseFormBody } from "./forms.ts";
+export { createRouteKernel, routeParams, toRouteRequest, wrapSecuredRouteModelByKey, wrapWebLogin, wrapWebRegister, } from "./routing.ts";
 export { convertAppRoutesToBunRoutes, createWebServer, type WebServerOptions } from "./server.ts";
 export { CookieSessionStore, type SessionUser } from "./session.ts";
 export { slugify } from "./slug.ts";

package/dist/bootstrap/web/routing.d.ts

@@ -0,0 +1,21 @@
+import type { RouteHandler, RouteRequest } from "@getstrata/core";
+import type { AppDependencies } from "../contracts.ts";
+import type { HttpKernel } from "../httpKernel.ts";
+/** Read Bun native `:param` values from a route handler request. */
+export declare function routeParams(request: Request): Record<string, string>;
+/**
+ * Attach decoded route params to Bun's native Request for RouteRequest handlers.
+ * Mutates the request in place so instanceof Request and Bun internals stay valid.
+ */
+export declare function toRouteRequest<TParams extends Record<string, string>>(request: Request): RouteRequest<TParams>;
+/** Laravel-style secured route-model binding for string keys (slugs, UUIDs). */
+export declare function wrapSecuredRouteModelByKey<TParams extends Record<string, string>, TModel, TParam extends keyof TParams & string>(param: TParam, resolver: (key: string, request: RouteRequest<TParams>) => Promise<TModel>, authorization: {
+    resource: string;
+    action: "view" | "create" | "update" | "delete";
+}, handler: (request: RouteRequest<TParams>, model: TModel) => Response | Promise<Response>): RouteHandler;
+/** Converts kernel login throttle 429 JSON into an HTML response for web forms. */
+export declare function wrapWebLogin(kernel: HttpKernel, handler: RouteHandler, onThrottled: (request: Request) => Response | Promise<Response>): RouteHandler;
+/** Converts kernel register throttle 429 JSON into an HTML response for web forms. */
+export declare function wrapWebRegister(kernel: HttpKernel, handler: RouteHandler, onThrottled: (request: Request) => Response | Promise<Response>): RouteHandler;
+/** Convenience alias: HttpKernel is the Laravel-style router middleware wrapper. */
+export declare function createRouteKernel(dependencies: AppDependencies): HttpKernel;

package/dist/bootstrap/web/session.d.ts

@@ -3,6 +3,7 @@ export interface SessionUser {
     name: string;
     email: string;
     learn_subscriber?: boolean;
+    is_admin?: boolean;
 }
 type SqlClient = {
     unsafe<T>(query: string, params?: readonly unknown[]): Promise<T[]>;

package/dist/core/admin/formatValue.d.ts

@@ -0,0 +1,3 @@
+import type { AdminColumnType } from "./types.ts";
+declare function formatAdminValue(value: unknown, type?: AdminColumnType): string;
+export { formatAdminValue };

package/dist/core/admin/index.d.ts

@@ -0,0 +1,3 @@
+export { formatAdminValue } from "./formatValue.ts";
+export { AdminResourceRegistry } from "./registry.ts";
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, } from "./types.ts";

package/dist/core/admin/registry.d.ts

@@ -0,0 +1,10 @@
+import type { AdminResource, AdminResourceDefinition } from "./types.ts";
+declare class AdminResourceRegistry {
+    private readonly resources;
+    register<TEntity extends object>(resource: AdminResource<TEntity>): void;
+    get(name: string): AdminResource<object> | undefined;
+    list(): AdminResourceDefinition[];
+    all(): AdminResource<object>[];
+    clear(): void;
+}
+export { AdminResourceRegistry };

package/dist/core/admin/types.d.ts

@@ -0,0 +1,24 @@
+import type { PaginatedResult } from "../pagination/index.ts";
+type AdminColumnType = "text" | "number" | "boolean" | "datetime" | "code";
+interface AdminColumn {
+    key: string;
+    label: string;
+    type?: AdminColumnType;
+}
+interface AdminResourceHandlers<TEntity extends object> {
+    paginate(options: {
+        page: number;
+        perPage: number;
+    }): Promise<PaginatedResult<TEntity>>;
+    findById?(id: number): Promise<TEntity | null>;
+}
+interface AdminResourceDefinition {
+    name: string;
+    label: string;
+    labelPlural: string;
+    columns: AdminColumn[];
+}
+interface AdminResource<TEntity extends object> extends AdminResourceDefinition {
+    handlers: AdminResourceHandlers<TEntity>;
+}
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, };

package/dist/core/auth/scimAuthMiddleware.d.ts

@@ -0,0 +1,3 @@
+import type { Middleware } from "../http/middleware";
+declare function createScimAuthMiddleware(): Middleware;
+export { createScimAuthMiddleware };

package/dist/core/database/baseRepository.d.ts

@@ -1,5 +1,5 @@
 import { type CursorPaginatedResult, type PaginatedResult } from "../pagination/index.ts";
-import { type BelongsToRelation, type HasManyRelation } from "./relationships.ts";
+import { type BelongsToRelation, type HasManyRelation, type MorphManyRelation, type MorphOneRelation, type MorphToRelation } from "./relationships.ts";
 import { RepositoryQuery } from "./repositoryQuery.ts";
 import type { TableDefinition } from "./table.ts";
 import type { MutationValues, QueryOptions, QueryWhere, UpdateValues } from "./types.ts";
@@ -54,6 +54,9 @@ declare class BaseRepository<TEntity extends object, PrimaryKey extends keyof TE
     findByHasManyRelation<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, parentId: TParent[LocalKey], options?: Omit<QueryOptions<TEntity>, "where">): Promise<TEntity[]>;
     loadHasManyForParents<TParent extends object, LocalKey extends keyof TParent & string, ForeignKey extends keyof TEntity & string>(parents: readonly TParent[], relation: HasManyRelation<TParent, TEntity, LocalKey, ForeignKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
     loadBelongsToForParents<TChild extends object, TParent extends object, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[ForeignKey], TParent>>;
+    loadMorphManyForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphManyRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity[]>>;
+    loadMorphOneForParents<TParent extends object, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string>(parents: readonly TParent[], relation: MorphOneRelation<TParent, TEntity, LocalKey, MorphTypeKey, MorphIdKey>, options?: Omit<QueryOptions<TEntity>, "where">): Promise<Map<TParent[LocalKey], TEntity | undefined>>;
+    loadMorphToForChildren<TChild extends object, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, OwnerKey>>, options?: Omit<QueryOptions<TParent>, "where">): Promise<Map<TChild[MorphIdKey], TParent>>;
 }
 export default BaseRepository;
 export type { DatabaseConnection };

package/dist/core/database/index.d.ts

@@ -5,8 +5,8 @@ export { mapDatabaseError, withDatabaseErrorHandling } from "./errors.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "./model.ts";
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "./model.ts";
 export { buildAdvancedWhereClause, buildCountQuery, buildDeleteByIdQuery, buildGroupedCountQuery, buildInsertQuery, buildJoinClause, buildOrderByClause, buildProjectionQuery, buildQueryWhereClause, buildRestoreByIdQuery, buildSelectQuery, buildSoftDeleteByIdQuery, buildUpdateQuery, buildWhereClause, parseQualifiedColumn, qualifyColumn, quoteIdentifier, resolveQualifiedColumn, resolveSoftDeleteColumn, } from "./query.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "./relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "./relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "./relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "./relationships.ts";
 export { RepositoryQuery } from "./repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "./schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "./schema/index.ts";

package/dist/core/database/relationships.d.ts

@@ -52,5 +52,49 @@ declare function indexHasManyRelation<TParent, TChild, LocalKey extends keyof TP
 declare function indexHasOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, ForeignKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: HasOneRelation<TParent, TChild, LocalKey, ForeignKey>): Map<TParent[LocalKey], TChild | undefined>;
 declare function indexBelongsToRelation<TChild, TParent, ForeignKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parents: readonly TParent[], relation: BelongsToRelation<TChild, TParent, ForeignKey, OwnerKey>): Map<TChild[ForeignKey], TParent>;
 declare function indexBelongsToManyRelation<TParent, TRelated, Pivot extends object, ParentKey extends keyof TParent & string, RelatedKey extends keyof TRelated & string, ForeignPivotKey extends keyof Pivot & string, RelatedPivotKey extends keyof Pivot & string>(parents: readonly TParent[], pivotRows: readonly Pivot[], relatedRows: readonly TRelated[], relation: BelongsToManyRelation<TParent, TRelated, Pivot, ParentKey, RelatedKey, ForeignPivotKey, RelatedPivotKey>): Map<TParent[ParentKey], TRelated[]>;
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation };
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, };
+interface MorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphMany";
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}
+interface MorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphOne";
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}
+interface MorphToRelation<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string> {
+    type: "morphTo";
+    name: string;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+}
+declare function morphMany<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}): MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
+declare function morphOne<TParent, TChild, LocalKey extends keyof TParent & string = keyof TParent & string, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    localKey: LocalKey;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+    morphType: string;
+}): MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>;
+declare function morphTo<TChild, MorphTypeKey extends keyof TChild & string = keyof TChild & string, MorphIdKey extends keyof TChild & string = keyof TChild & string>(definition: {
+    name: string;
+    morphTypeKey: MorphTypeKey;
+    morphIdKey: MorphIdKey;
+}): MorphToRelation<TChild, MorphTypeKey, MorphIdKey>;
+declare function indexMorphManyRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphManyRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild[]>;
+declare function indexMorphOneRelation<TParent, TChild, LocalKey extends keyof TParent & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string>(parents: readonly TParent[], children: readonly TChild[], relation: MorphOneRelation<TParent, TChild, LocalKey, MorphTypeKey, MorphIdKey>): Map<TParent[LocalKey], TChild | undefined>;
+declare function indexMorphToRelation<TChild, TParent extends object, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, OwnerKey extends keyof TParent & string>(children: readonly TChild[], parentsByType: ReadonlyMap<string, ReadonlyMap<TParent[OwnerKey], TParent>>, relation: MorphToRelation<TChild, MorphTypeKey, MorphIdKey>): Map<TChild[MorphIdKey], TParent>;
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, };
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, };

package/dist/core/database/repositoryQuery.d.ts

@@ -1,6 +1,6 @@
 import type { PaginatedResult } from "../pagination/index.ts";
 import type BaseRepository from "./baseRepository.ts";
-import type { BelongsToRelation, HasManyRelation } from "./relationships.ts";
+import type { BelongsToRelation, HasManyRelation, MorphManyRelation, MorphOneRelation, MorphToRelation } from "./relationships.ts";
 import type { QueryOptions, QueryWhere } from "./types.ts";
 import { WhereBuilder } from "./whereBuilder.ts";
 type LoadedRow = Record<string, unknown>;
@@ -22,6 +22,9 @@ declare class RepositoryQuery<TEntity extends object, PrimaryKey extends keyof T
     having(having: QueryWhere<TEntity>): this;
     withHasMany<TChild extends object, LocalKey extends keyof TEntity & string, ForeignKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: HasManyRelation<TEntity, TChild, LocalKey, ForeignKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
     withBelongsTo<TParent extends object, ForeignKey extends keyof TEntity & string, OwnerKey extends keyof TParent & string, Alias extends string>(as: Alias, relation: BelongsToRelation<TEntity, TParent, ForeignKey, OwnerKey>, parentRepository: BaseRepository<TParent, OwnerKey>, options?: Omit<QueryOptions<TParent>, "where">): this;
+    withMorphMany<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphManyRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withMorphOne<TChild extends object, LocalKey extends keyof TEntity & string, MorphTypeKey extends keyof TChild & string, MorphIdKey extends keyof TChild & string, Alias extends string>(as: Alias, relation: MorphOneRelation<TEntity, TChild, LocalKey, MorphTypeKey, MorphIdKey>, childRepository: BaseRepository<TChild, keyof TChild & string>, options?: Omit<QueryOptions<TChild>, "where">): this;
+    withMorphTo<TParent extends object, MorphTypeKey extends keyof TEntity & string, MorphIdKey extends keyof TEntity & string, Alias extends string>(as: Alias, relation: MorphToRelation<TEntity, MorphTypeKey, MorphIdKey>, repositoriesByType: ReadonlyMap<string, BaseRepository<TParent, keyof TParent & string>>, options?: Omit<QueryOptions<TParent>, "where">): this;
     get(): Promise<Array<TEntity & LoadedRow>>;
     first(): Promise<(TEntity & LoadedRow) | null>;
     paginate(options: {

package/dist/core/http/scimThrottleMiddleware.d.ts

@@ -0,0 +1,9 @@
+import type { Middleware } from "./middleware";
+interface ScimThrottleOptions {
+    redisUrl?: string;
+    maxAttempts: number;
+    decaySeconds: number;
+}
+declare function createScimThrottleMiddleware(options: ScimThrottleOptions): Middleware;
+export type { ScimThrottleOptions };
+export { createScimThrottleMiddleware };

package/dist/core/mail/mailer.d.ts

@@ -2,6 +2,7 @@ interface MailMessage {
     to: string;
     subject: string;
     body: string;
+    html?: string;
 }
 interface MailDriver {
     send(message: MailMessage): Promise<void>;
@@ -16,6 +17,7 @@ interface SmtpConfig {
 }
 type SmtpTransport = (config: SmtpConfig, message: MailMessage) => Promise<void>;
 declare function resolveSmtpConfig(): SmtpConfig;
+declare function buildSmtpPayload(from: string, message: MailMessage): string;
 declare class LogMailDriver implements MailDriver {
     send(message: MailMessage): Promise<void>;
 }
@@ -33,4 +35,4 @@ declare class Mailer {
 declare function createMailDriver(): MailDriver;
 declare function mailer(): Mailer;
 export type { MailDriver, MailMessage, SmtpConfig, SmtpTransport };
-export { createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver };
+export { buildSmtpPayload, createMailDriver, LogMailDriver, Mailer, mailer, resolveSmtpConfig, SmtpMailDriver, };

package/dist/core/mail/markdownMail.d.ts

@@ -0,0 +1,15 @@
+interface MarkdownMailLayoutOptions {
+    title?: string;
+    preview?: string;
+    footer?: string;
+}
+interface RenderedMarkdownMail {
+    html: string;
+    text: string;
+}
+declare function stripMarkdown(markdown: string): string;
+declare function markdownToHtml(markdown: string): string;
+declare function wrapMarkdownMailLayout(bodyHtml: string, options?: MarkdownMailLayoutOptions): string;
+declare function renderMarkdownMail(markdown: string, options?: MarkdownMailLayoutOptions): RenderedMarkdownMail;
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail };
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout };

package/dist/core/mail/markdownMailable.d.ts

@@ -0,0 +1,12 @@
+import type { Mailer, MailMessage } from "./mailer.ts";
+import { type MarkdownMailLayoutOptions } from "./markdownMail.ts";
+interface MarkdownMailableInput {
+    to: string;
+    subject: string;
+    markdown: string;
+    layout?: MarkdownMailLayoutOptions;
+}
+declare function buildMarkdownMailMessage(input: MarkdownMailableInput): MailMessage;
+declare function sendMarkdownMail(mailer: Mailer, input: MarkdownMailableInput): Promise<void>;
+export type { MarkdownMailableInput };
+export { buildMarkdownMailMessage, sendMarkdownMail };

package/dist/core/notifications/dispatcher.d.ts

@@ -0,0 +1,13 @@
+import type { Mailer } from "../mail/mailer.ts";
+import type { Notification } from "./notification.ts";
+import type { DatabaseNotificationStore, Notifiable } from "./types.ts";
+declare class NotificationDispatcher {
+    private readonly mailer;
+    private readonly databaseStore;
+    constructor(mailer: Mailer, databaseStore?: DatabaseNotificationStore | null);
+    send(notifiable: Notifiable, notification: Notification): Promise<void>;
+    private sendMail;
+    private sendDatabase;
+}
+declare function createNotificationDispatcher(mailer: Mailer, databaseStore?: DatabaseNotificationStore): NotificationDispatcher;
+export { createNotificationDispatcher, NotificationDispatcher };

package/dist/core/notifications/index.d.ts

@@ -0,0 +1,3 @@
+export { createNotificationDispatcher, NotificationDispatcher } from "./dispatcher.ts";
+export { Notification } from "./notification.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "./types.ts";

package/dist/core/notifications/notification.d.ts

@@ -0,0 +1,7 @@
+import type { DatabaseNotificationPayload, MailNotificationMessage, NotificationChannelName } from "./types.ts";
+declare abstract class Notification<TNotifiable = unknown> {
+    via(_notifiable: TNotifiable): NotificationChannelName[];
+    toMail(_notifiable: TNotifiable): MailNotificationMessage | null;
+    toDatabase(_notifiable: TNotifiable): DatabaseNotificationPayload | null;
+}
+export { Notification };

package/dist/core/notifications/types.d.ts

@@ -0,0 +1,25 @@
+type NotificationChannelName = "mail" | "database";
+interface MailNotificationMessage {
+    subject: string;
+    markdown?: string;
+    body?: string;
+    html?: string;
+}
+interface DatabaseNotificationPayload {
+    type: string;
+    title: string;
+    body: string;
+    data?: Record<string, unknown>;
+    notifiableType?: string | null;
+    notifiableId?: number | null;
+}
+interface DatabaseNotificationStore {
+    create(input: DatabaseNotificationPayload & {
+        userId: number;
+    }): Promise<Record<string, unknown>>;
+}
+interface Notifiable {
+    getNotificationKey(): string | number;
+    routeNotificationFor(channel: NotificationChannelName): string | number | null;
+}
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, };

package/dist/core/queue/failedJobService.d.ts

@@ -10,6 +10,7 @@ declare class FailedJobService {
     }): Promise<FailedJobRecord>;
     listRecent(limit?: number): Promise<FailedJobRecord[]>;
     retry(id: number): Promise<FailedJobRecord>;
+    delete(id: number): Promise<void>;
     flush(): Promise<number>;
 }
 export default FailedJobService;

package/dist/core/queue/publicQueue.d.ts

@@ -2,6 +2,7 @@ import FailedJobRepository from "./failedJobRepository.ts";
 import FailedJobService from "./failedJobService.ts";
 import type { Job, Queue } from "./index.ts";
 import { jobRegistry } from "./jobRegistry.ts";
+import { runQueueJob } from "./jobRunner.ts";
 import { QueueWorker, RedisQueue } from "./redisQueue.ts";
 import { ResilientQueue } from "./resilientQueue.ts";
 declare function createFailedJobService(): FailedJobService;
@@ -12,4 +13,4 @@ declare function createProductionQueue(driver: "sync" | "async" | "redis", optio
     registerJobs?: () => void;
 }): Queue;
 declare function createQueueWorker(redisUrl: string, failedJobs?: FailedJobService): QueueWorker;
-export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, };
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, };

package/dist/core/security/scimTenantTokens.d.ts

@@ -0,0 +1,3 @@
+declare function parseScimTenantTokens(raw: string | undefined): Map<number, string>;
+declare function resolveScimTenantFromToken(token: string): number | null;
+export { parseScimTenantTokens, resolveScimTenantFromToken };

package/dist/core/security/timingSafeCompare.d.ts

@@ -0,0 +1,2 @@
+declare function timingSafeCompareString(left: string, right: string): boolean;
+export { timingSafeCompareString };

package/dist/framework/public-api.d.ts

@@ -5,6 +5,8 @@
 export { resolveApplicationAuth, resolveApplicationCache, resolveApplicationConfig, resolveApplicationDependencies, resolveApplicationLogger, resolveApplicationPolicyGate, resolveApplicationQueue, setActiveApplicationContext, } from "../bootstrap/applicationRegistry.ts";
 export type { ServiceProvider } from "../bootstrap/contracts.ts";
 export { ConfigStore, resolveService, ServiceContainer, } from "../bootstrap/contracts.ts";
+export type { AdminColumn, AdminColumnType, AdminResource, AdminResourceDefinition, AdminResourceHandlers, } from "../core/admin/index.ts";
+export { AdminResourceRegistry, formatAdminValue, } from "../core/admin/index.ts";
 export type { AbilityChecker } from "../core/auth/abilityChecker.ts";
 export type { AuthUser } from "../core/auth/authContext.ts";
 export { currentAuthUser, runWithAuthUser } from "../core/auth/authContext.ts";
@@ -21,8 +23,8 @@ export { freshDatabase, getMigrationStatus, loadMigrationsFromDirectory, migrate
 export type { Migration, MigrationDatabase, MigrationStatus, } from "../core/database/migrations/types.ts";
 export type { CastType, GlobalScopeFn, ModelConstructor } from "../core/database/model.ts";
 export { applyCasts, dehydrateValue, filterMassAssignable, hydrateValue, Model, registerModelRepository, } from "../core/database/model.ts";
-export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, } from "../core/database/relationships.ts";
-export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, } from "../core/database/relationships.ts";
+export type { BelongsToManyRelation, BelongsToRelation, HasManyRelation, HasOneRelation, MorphManyRelation, MorphOneRelation, MorphToRelation, } from "../core/database/relationships.ts";
+export { belongsTo, belongsToMany, hasMany, hasOne, indexBelongsToManyRelation, indexBelongsToRelation, indexHasManyRelation, indexHasOneRelation, indexMorphManyRelation, indexMorphOneRelation, indexMorphToRelation, morphMany, morphOne, morphTo, } from "../core/database/relationships.ts";
 export { RepositoryQuery } from "../core/database/repositoryQuery.ts";
 export type { BlueprintAction, BlueprintCallback, ColumnKind, DatabaseDriver, ForeignKeyOptions, Grammar, IndexDefinition, IndexKind, ResolveDatabaseDriverOptions, SchemaBuilder, } from "../core/database/schema/index.ts";
 export { Blueprint, ColumnDefinition, compileBlueprint, createSchemaBuilder, ForeignIdColumnDefinition, grammarForDriver, inferReferencedTable, MySqlGrammar, PostgresGrammar, resolveDatabaseDriver, Schema, SqliteGrammar, UnsupportedSchemaFeatureError, } from "../core/database/schema/index.ts";
@@ -56,13 +58,19 @@ export { createThrottleMiddleware } from "../core/http/throttleMiddleware.ts";
 export { WebFormRequest } from "../core/http/webFormRequest.ts";
 export { installGracefulShutdownSignals, registerShutdownHandler, runGracefulShutdown, } from "../core/lifecycle/gracefulShutdown.ts";
 export type { MailDriver, MailMessage } from "../core/mail/mailer.ts";
-export { LogMailDriver, Mailer, mailer } from "../core/mail/mailer.ts";
+export { buildSmtpPayload, LogMailDriver, Mailer, mailer, } from "../core/mail/mailer.ts";
+export type { MarkdownMailLayoutOptions, RenderedMarkdownMail } from "../core/mail/markdownMail.ts";
+export { markdownToHtml, renderMarkdownMail, stripMarkdown, wrapMarkdownMailLayout, } from "../core/mail/markdownMail.ts";
+export type { MarkdownMailableInput } from "../core/mail/markdownMailable.ts";
+export { buildMarkdownMailMessage, sendMarkdownMail } from "../core/mail/markdownMailable.ts";
 export type { MetricLabels } from "../core/metrics/prometheus.ts";
 export { PrometheusRegistry, prometheusRegistry } from "../core/metrics/prometheus.ts";
+export type { DatabaseNotificationPayload, DatabaseNotificationStore, MailNotificationMessage, Notifiable, NotificationChannelName, } from "../core/notifications/index.ts";
+export { createNotificationDispatcher, Notification, NotificationDispatcher, } from "../core/notifications/index.ts";
 export type { CursorPaginatedResult, PaginatedResult, PaginationMeta, } from "../core/pagination/index.ts";
 export type { Queue, QueuePriority } from "../core/queue/index.ts";
 export { AsyncQueue, createQueue, Job, SyncQueue } from "../core/queue/index.ts";
-export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, } from "../core/queue/publicQueue.ts";
+export { createFailedJobService, createProductionQueue, createQueueWorker, createTrackedJob, FailedJobRepository, FailedJobService, jobRegistry, QueueWorker, RedisQueue, ResilientQueue, runQueueJob, } from "../core/queue/publicQueue.ts";
 export type { ScheduledTask } from "../core/scheduler/schedule.ts";
 export { appSchedule, runDueScheduledTasks, Schedule } from "../core/scheduler/schedule.ts";
 export type { StorageDriver } from "../core/storage/storage.ts";

package/dist/index.js

@@ -2347,6 +2347,39 @@ function indexBelongsToRelation(children, parents, relation) {
   }
   return result;
 }
+function indexMorphManyRelation(parents, children, relation) {
+  const groups = new Map;
+  for (const parent of parents) {
+    groups.set(parent[relation.localKey], []);
+  }
+  for (const child of children) {
+    if (child[relation.morphTypeKey] !== relation.morphType) {
+      continue;
+    }
+    const key = child[relation.morphIdKey];
+    const group = groups.get(key);
+    if (!group) {
+      continue;
+    }
+    group.push(child);
+  }
+  return groups;
+}
+function indexMorphToRelation(children, parentsByType, relation) {
+  const result = new Map;
+  for (const child of children) {
+    const morphType = String(child[relation.morphTypeKey]);
+    const parents = parentsByType.get(morphType);
+    if (!parents) {
+      continue;
+    }
+    const parent = parents.get(child[relation.morphIdKey]);
+    if (parent) {
+      result.set(child[relation.morphIdKey], parent);
+    }
+  }
+  return result;
+}
 
 // ../../src/core/database/boundConnection.ts
 var boundConnectionHolder = {
@@ -2477,6 +2510,37 @@ class RepositoryQuery {
     });
     return this;
   }
+  withMorphMany(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphMany",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphOne(as, relation, childRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphOne",
+      as,
+      relation,
+      repository: childRepository,
+      options
+    });
+    return this;
+  }
+  withMorphTo(as, relation, repositoriesByType, options = {}) {
+    this.eagerLoads.push({
+      kind: "morphTo",
+      as,
+      relation,
+      repository: this.repository,
+      morphRepositories: repositoriesByType,
+      options
+    });
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -2537,6 +2601,33 @@ class RepositoryQuery {
         }));
         continue;
       }
+      if (load.kind === "morphMany") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+        }));
+        continue;
+      }
+      if (load.kind === "morphOne") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.localKey])
+        }));
+        continue;
+      }
+      if (load.kind === "morphTo") {
+        const relation2 = load.relation;
+        const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: grouped2.get(row[relation2.morphIdKey])
+        }));
+        continue;
+      }
       const relation = load.relation;
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
@@ -2813,6 +2904,56 @@ class BaseRepository5 {
     }, options);
     return indexBelongsToRelation(children, parents, relation);
   }
+  async loadMorphManyForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexMorphManyRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const children = await this.findWhere({
+      [relation.morphTypeKey]: relation.morphType,
+      [relation.morphIdKey]: parentIds
+    }, options);
+    return indexMorphManyRelation(parents, children, relation);
+  }
+  async loadMorphOneForParents(parents, relation, options = {}) {
+    const grouped = await this.loadMorphManyForParents(parents, relation, options);
+    const result = new Map;
+    for (const parent of parents) {
+      const matches = grouped.get(parent[relation.localKey]) ?? [];
+      result.set(parent[relation.localKey], matches[0]);
+    }
+    return result;
+  }
+  async loadMorphToForChildren(children, relation, repositoriesByType, options = {}) {
+    if (children.length === 0) {
+      return new Map;
+    }
+    const idsByType = new Map;
+    for (const child of children) {
+      const morphType = String(child[relation.morphTypeKey]);
+      const morphId = child[relation.morphIdKey];
+      const ids = idsByType.get(morphType) ?? new Set;
+      ids.add(morphId);
+      idsByType.set(morphType, ids);
+    }
+    const parentsByType = new Map;
+    for (const [morphType, ids] of idsByType) {
+      const repository = repositoriesByType.get(morphType);
+      if (!repository) {
+        continue;
+      }
+      const ownerKey = repository.getTable().primaryKey;
+      const parents = await repository.withConnection(this.connection).findWhere({
+        [ownerKey]: [...ids]
+      }, options);
+      const indexed = new Map;
+      for (const parent of parents) {
+        indexed.set(parent[ownerKey], parent);
+      }
+      parentsByType.set(morphType, indexed);
+    }
+    return indexMorphToRelation(children, parentsByType, relation);
+  }
 }
 var baseRepository_default = BaseRepository5;
 // ../../src/core/database/model.ts
@@ -3429,6 +3570,12 @@ class FailedJobService {
     await this.repository.deleteById(id);
     return failedJob;
   }
+  async delete(id) {
+    const deleted = await this.repository.deleteById(id);
+    if (!deleted) {
+      throw new Error(`Failed job ${id} not found.`);
+    }
+  }
   async flush() {
     const jobs = await this.repository.findAll();
     let deleted = 0;
@@ -3442,9 +3589,6 @@ class FailedJobService {
 }
 var failedJobService_default = FailedJobService;
 
-// ../../src/core/queue/redisQueue.ts
-var {RedisClient: RedisClient2 } = globalThis.Bun;
-
 // ../../src/core/queue/jobRunner.ts
 async function runQueueJob(envelope, failedJobs) {
   const job = jobRegistry.create(envelope.name);
@@ -3476,6 +3620,7 @@ async function runQueueJob(envelope, failedJobs) {
 }
 
 // ../../src/core/queue/redisQueue.ts
+var {RedisClient: RedisClient2 } = globalThis.Bun;
 var QUEUE_LIST_KEY = "workhub:queue:default";
 var QUEUE_HIGH_KEY = "workhub:queue:high";
 var QUEUE_LOW_KEY = "workhub:queue:low";
@@ -5333,6 +5478,51 @@ async function parseFormBody(request) {
   }
   return { fields, files };
 }
+// ../../src/bootstrap/web/routing.ts
+import { securedBindRouteModelByKey, withErrorHandling } from "@getstrata/core";
+function routeParams(request) {
+  const normalized = {};
+  const raw = request.params;
+  if (raw && typeof raw === "object") {
+    for (const [key, value] of Object.entries(raw)) {
+      normalized[key] = decodeURIComponent(String(value));
+    }
+  }
+  return normalized;
+}
+function toRouteRequest(request) {
+  const params = routeParams(request);
+  Object.defineProperty(request, "params", {
+    value: params,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
+  return request;
+}
+function wrapSecuredRouteModelByKey(param, resolver, authorization, handler) {
+  const bound = withErrorHandling(securedBindRouteModelByKey(param, resolver, authorization, handler));
+  return async (request) => bound(toRouteRequest(request));
+}
+function wrapWebLogin(kernel, handler, onThrottled) {
+  return wrapWebThrottle(kernel, "login", handler, onThrottled);
+}
+function wrapWebRegister(kernel, handler, onThrottled) {
+  return wrapWebThrottle(kernel, "register", handler, onThrottled);
+}
+function wrapWebThrottle(kernel, scope, handler, onThrottled) {
+  const throttled = scope === "login" ? kernel.wrapLogin(handler) : kernel.wrapRegister(handler);
+  return async (request) => {
+    const response = await throttled(request);
+    if (response.status === 429) {
+      return onThrottled(request);
+    }
+    return response;
+  };
+}
+function createRouteKernel(dependencies) {
+  return createHttpKernel(dependencies);
+}
 // ../../src/bootstrap/web/server.ts
 function wrapRouteHandler2(handler) {
   return async (request) => {
@@ -5433,7 +5623,8 @@ class CookieSessionStore {
     if (!sessionId || !signature || signature !== this.sign(sessionId)) {
       return null;
     }
-    const rows = await this.sql.unsafe(`SELECT s.id, s.user_id, s.expires_at, u.name, u.email, u.learn_subscriber
+    const rows = await this.sql.unsafe(`SELECT s.id, s.user_id, s.expires_at, u.name, u.email, u.learn_subscriber,
+              COALESCE(u.is_admin, false) AS is_admin
        FROM sessions s
        INNER JOIN users u ON u.id = s.user_id
        WHERE s.id = $1 AND s.expires_at > NOW()`, [sessionId]);
@@ -5444,7 +5635,8 @@ class CookieSessionStore {
       id: row.user_id,
       name: row.name,
       email: row.email,
-      learn_subscriber: row.learn_subscriber
+      learn_subscriber: row.learn_subscriber,
+      is_admin: row.is_admin
     };
   }
   sign(value) {
@@ -5456,11 +5648,16 @@ function slugify(value) {
   return value.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
 }
 export {
+  wrapWebRegister,
+  wrapWebLogin,
+  wrapSecuredRouteModelByKey,
+  toRouteRequest,
   slugify,
   setActiveApplicationContext2 as setActiveApplicationContext,
   scheduleRunCommand,
   runProviderPhase,
   runDueScheduledTasks,
+  routeParams,
   resolveService,
   resolveApplicationQueue2 as resolveApplicationQueue,
   prefixRouteMap,
@@ -5469,6 +5666,7 @@ export {
   getRequiredDependency,
   createWebServer,
   createWebRoutes,
+  createRouteKernel,
   createHttpKernel,
   createCsrfProtection,
   createAppContext,

package/dist/modules/scim/controller.d.ts

@@ -0,0 +1,15 @@
+import type { AppDependencies } from "@getstrata/bootstrap/contracts";
+declare class ScimController {
+    private readonly service;
+    constructor(dependencies: AppDependencies);
+    readonly serviceProviderConfig: () => Promise<Response>;
+    readonly listUsers: (request: Request) => Promise<Response>;
+    readonly createUser: (request: Request) => Promise<Response>;
+    readonly showUser: (request: Request) => Promise<Response>;
+    readonly patchUser: (request: Request) => Promise<Response>;
+    readonly deleteUser: (request: Request) => Promise<Response>;
+    readonly listGroups: (request: Request) => Promise<Response>;
+    readonly showGroup: (request: Request) => Promise<Response>;
+    readonly patchGroup: (request: Request) => Promise<Response>;
+}
+export default ScimController;

package/dist/modules/scim/scimResponse.d.ts

@@ -0,0 +1,10 @@
+import { type EtagVersioned } from "@getstrata/core/http/etag";
+interface ScimResponseOptions {
+    status?: number;
+    request?: Request;
+    etagSource?: EtagVersioned;
+}
+declare function scimResponse(data: unknown, options?: ScimResponseOptions): Response;
+declare function assertScimIfMatch(request: Request, etagSource: EtagVersioned): void;
+export type { ScimResponseOptions };
+export { assertScimIfMatch, scimResponse };

package/dist/modules/scim/service.d.ts

@@ -0,0 +1,217 @@
+import type { AppDependencies } from "@getstrata/bootstrap/contracts";
+import OrganizationMemberRepository from "../organization/memberRepository";
+import type UserRepository from "../user/repository";
+interface ScimUserPayload {
+    userName?: string;
+    name?: {
+        formatted?: string;
+    };
+    active?: boolean;
+    emails?: Array<{
+        value: string;
+        primary?: boolean;
+    }>;
+}
+interface ScimPatchOperation {
+    op: string;
+    path?: string;
+    value?: unknown;
+}
+declare class ScimService {
+    private readonly users;
+    private readonly members;
+    constructor(users: UserRepository, members: OrganizationMemberRepository);
+    serviceProviderConfig(): {
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:ServiceProviderConfig"[];
+        patch: {
+            supported: boolean;
+        };
+        bulk: {
+            supported: boolean;
+        };
+        filter: {
+            supported: boolean;
+        };
+        changePassword: {
+            supported: boolean;
+        };
+        sort: {
+            supported: boolean;
+        };
+        etag: {
+            supported: boolean;
+        };
+        authenticationSchemes: {
+            type: string;
+            name: string;
+            description: string;
+        }[];
+    };
+    listUsers(startIndex?: number, count?: number): Promise<{
+        schemas: "urn:ietf:params:scim:api:messages:2.0:ListResponse"[];
+        totalResults: number;
+        startIndex: number;
+        itemsPerPage: number;
+        Resources: {
+            schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+            id: string;
+            userName: string;
+            name: {
+                formatted: string;
+            };
+            displayName: string;
+            active: boolean;
+            emails: {
+                value: string;
+                primary: boolean;
+                type: string;
+            }[];
+            roles: {
+                value: string;
+                primary: boolean;
+            }[];
+            meta: {
+                resourceType: string;
+                created: string | undefined;
+                lastModified: string | undefined;
+            };
+        }[];
+    }>;
+    getUser(id: number): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    findUserRecord(id: number): Promise<import("../user/types").UserRecord>;
+    createUser(payload: ScimUserPayload): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    patchUser(id: number, operations: ScimPatchOperation[]): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:User"[];
+        id: string;
+        userName: string;
+        name: {
+            formatted: string;
+        };
+        displayName: string;
+        active: boolean;
+        emails: {
+            value: string;
+            primary: boolean;
+            type: string;
+        }[];
+        roles: {
+            value: string;
+            primary: boolean;
+        }[];
+        meta: {
+            resourceType: string;
+            created: string | undefined;
+            lastModified: string | undefined;
+        };
+    }>;
+    deleteUser(id: number): Promise<{
+        id: number;
+        updated_at: Date;
+    }>;
+    listGroups(startIndex?: number, count?: number): Promise<{
+        schemas: "urn:ietf:params:scim:api:messages:2.0:ListResponse"[];
+        totalResults: number;
+        startIndex: number;
+        itemsPerPage: number;
+        Resources: {
+            schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+            id: string;
+            displayName: string;
+            externalId: string;
+            members: {
+                value: string;
+                display: string;
+            }[];
+            meta: {
+                resourceType: string;
+                lastModified: string;
+            };
+        }[];
+    }>;
+    getGroup(id: number): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+        id: string;
+        displayName: string;
+        externalId: string;
+        members: {
+            value: string;
+            display: string;
+        }[];
+        meta: {
+            resourceType: string;
+            lastModified: string;
+        };
+    }>;
+    findOrganizationRecord(id: number): Promise<{
+        id: number;
+        name: string;
+        slug: string;
+        updated_at: Date;
+    }>;
+    patchGroup(id: number, operations: ScimPatchOperation[]): Promise<{
+        schemas: "urn:ietf:params:scim:schemas:core:2.0:Group"[];
+        id: string;
+        displayName: string;
+        externalId: string;
+        members: {
+            value: string;
+            display: string;
+        }[];
+        meta: {
+            resourceType: string;
+            lastModified: string;
+        };
+    }>;
+    private toScimGroup;
+    private toScimUser;
+}
+declare function createScimService(dependencies: AppDependencies): ScimService;
+export default ScimService;
+export type { ScimPatchOperation, ScimUserPayload };
+export { createScimService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/bootstrap",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "Strata application bootstrap — HttpKernel, DI, web session helpers",
   "type": "module",
   "license": "MIT",
@@ -16,42 +16,42 @@
       "default": "./dist/index.js"
     },
     "./applicationRegistry": {
-      "types": "./dist/entries/applicationRegistry.d.ts",
+      "types": "./dist/bootstrap/applicationRegistry.d.ts",
       "import": "./dist/entries/applicationRegistry.js",
       "default": "./dist/entries/applicationRegistry.js"
     },
     "./config": {
-      "types": "./dist/entries/config.d.ts",
+      "types": "./dist/bootstrap/config.d.ts",
       "import": "./dist/entries/config.js",
       "default": "./dist/entries/config.js"
     },
     "./context": {
-      "types": "./dist/entries/context.d.ts",
+      "types": "./dist/bootstrap/context.d.ts",
       "import": "./dist/entries/context.js",
       "default": "./dist/entries/context.js"
     },
     "./contracts": {
-      "types": "./dist/entries/contracts.d.ts",
+      "types": "./dist/bootstrap/contracts.d.ts",
       "import": "./dist/entries/contracts.js",
       "default": "./dist/entries/contracts.js"
     },
     "./createWebRoutes": {
-      "types": "./dist/entries/createWebRoutes.d.ts",
+      "types": "./dist/bootstrap/createWebRoutes.d.ts",
       "import": "./dist/entries/createWebRoutes.js",
       "default": "./dist/entries/createWebRoutes.js"
     },
     "./httpKernel": {
-      "types": "./dist/entries/httpKernel.d.ts",
+      "types": "./dist/bootstrap/httpKernel.d.ts",
       "import": "./dist/entries/httpKernel.js",
       "default": "./dist/entries/httpKernel.js"
     },
     "./providers": {
-      "types": "./dist/entries/providers.d.ts",
+      "types": "./dist/bootstrap/providers/index.d.ts",
       "import": "./dist/entries/providers.js",
       "default": "./dist/entries/providers.js"
     },
     "./providers/view": {
-      "types": "./dist/entries/providers/view.d.ts",
+      "types": "./dist/bootstrap/providers/view/index.d.ts",
       "import": "./dist/entries/providers/view.js",
       "default": "./dist/entries/providers/view.js"
     }
@@ -73,7 +73,7 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@getstrata/core": "^0.5.6",
+    "@getstrata/core": "^0.5.9",
     "typescript": "^5.9.0"
   }
 }