@lastshotlabs/bunshot 0.0.27 → 0.0.28

package/dist/src/cli/index.d.ts

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

package/dist/src/cli/index.js

@@ -0,0 +1,3 @@
+import { flush, run } from '@oclif/core';
+await run(process.argv.slice(2), import.meta.url);
+await flush();

package/dist/src/entrypoints/mongo.d.ts

@@ -0,0 +1,6 @@
+export { connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo, getMongoFromApp, getMongooseModule, } from '../lib/mongo';
+export type { MongoConnections } from '../lib/mongo';
+export { createMongoAuthAdapter } from '../../packages/bunshot-auth/src/adapters/mongoAuth';
+export { createAuthUserModel } from '../../packages/bunshot-auth/src/models/AuthUser';
+export { zodToMongoose } from '../framework/lib/zodToMongoose';
+export type { ZodToMongooseConfig, ZodToMongooseRefConfig } from '../framework/lib/zodToMongoose';

package/dist/src/entrypoints/mongo.js

@@ -0,0 +1,4 @@
+export { connectMongo, connectAuthMongo, connectAppMongo, disconnectMongo, getMongoFromApp, getMongooseModule, } from '../lib/mongo';
+export { createMongoAuthAdapter } from '../../packages/bunshot-auth/src/adapters/mongoAuth';
+export { createAuthUserModel } from '../../packages/bunshot-auth/src/models/AuthUser';
+export { zodToMongoose } from '../framework/lib/zodToMongoose';

package/dist/src/entrypoints/queue.d.ts

@@ -0,0 +1,2 @@
+export { createQueueFactory } from '../lib/queue';
+export type { Job, BunshotWorker, CronSchedule, DLQOptions, QueueFactory, QueueRedisCredentials, } from '../lib/queue';

package/dist/src/entrypoints/queue.js

@@ -0,0 +1 @@
+export { createQueueFactory } from '../lib/queue';

package/dist/src/entrypoints/redis.d.ts

@@ -0,0 +1 @@
+export { connectRedis, disconnectRedis, getRedisConnectionOptions, getRedisFromApp, } from '../lib/redis';

package/dist/src/entrypoints/redis.js

@@ -0,0 +1 @@
+export { connectRedis, disconnectRedis, getRedisConnectionOptions, getRedisFromApp, } from '../lib/redis';

package/dist/{adapters → src/framework/adapters}/localStorage.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from "../lib/storageAdapter";
+import type { StorageAdapter } from '../lib/storageAdapter';
 export interface LocalStorageConfig {
     directory: string;
     baseUrl?: string;

package/dist/{adapters → src/framework/adapters}/localStorage.js

@@ -1,17 +1,17 @@
-import { unlink } from "node:fs/promises";
-import { resolve, sep, dirname } from "node:path";
-import { HttpError } from "../lib/HttpError";
+import { unlink } from 'node:fs/promises';
+import { dirname, resolve, sep } from 'node:path';
+import { HttpError } from '../../../packages/bunshot-core/src/index.js';
 function resolveKey(directory, key) {
     if (!key || !key.trim())
-        throw new HttpError(400, "Invalid storage key");
-    const normalized = key.replace(/\\/g, "/");
-    if (normalized.startsWith("/") || /^[a-zA-Z]:/.test(normalized) || normalized.startsWith("//")) {
-        throw new HttpError(400, "Invalid storage key");
+        throw new HttpError(400, 'Invalid storage key');
+    const normalized = key.replace(/\\/g, '/');
+    if (normalized.startsWith('/') || /^[a-zA-Z]:/.test(normalized) || normalized.startsWith('//')) {
+        throw new HttpError(400, 'Invalid storage key');
     }
     const root = resolve(directory);
     const candidate = resolve(root, normalized);
     if (candidate === root || !candidate.startsWith(root + sep)) {
-        throw new HttpError(400, "Invalid storage key");
+        throw new HttpError(400, 'Invalid storage key');
     }
     return candidate;
 }
@@ -21,7 +21,7 @@ export const localStorage = (config) => ({
         // Ensure parent directory exists
         const dir = dirname(filePath);
         if (dir) {
-            const { mkdir } = await import("node:fs/promises");
+            const { mkdir } = await import('node:fs/promises');
             await mkdir(dir, { recursive: true });
         }
         if (data instanceof Blob) {
@@ -35,7 +35,7 @@ export const localStorage = (config) => ({
         else {
             await Bun.write(filePath, data);
         }
-        const url = config.baseUrl ? `${config.baseUrl.replace(/\/$/, "")}/${key}` : undefined;
+        const url = config.baseUrl ? `${config.baseUrl.replace(/\/$/, '')}/${key}` : undefined;
         return { ...(url !== undefined ? { url } : {}) };
     },
     async get(key) {

package/dist/src/framework/adapters/memoryStorage.d.ts

@@ -0,0 +1,2 @@
+import type { StorageAdapter } from '../lib/storageAdapter';
+export declare const memoryStorage: () => StorageAdapter;

package/dist/src/framework/adapters/memoryStorage.js

@@ -0,0 +1,45 @@
+import { DEFAULT_MAX_ENTRIES, evictOldest } from '../../../packages/bunshot-core/src/index.js';
+export const memoryStorage = () => {
+    const store = new Map();
+    return {
+        async put(key, data, meta) {
+            let buf;
+            if (data instanceof Blob) {
+                buf = Buffer.from(await data.arrayBuffer());
+            }
+            else if (data instanceof ReadableStream) {
+                const chunks = [];
+                const reader = data.getReader();
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    if (value)
+                        chunks.push(value);
+                }
+                buf = Buffer.concat(chunks);
+            }
+            else {
+                buf = data;
+            }
+            evictOldest(store, DEFAULT_MAX_ENTRIES);
+            store.set(key, { data: buf, mimeType: meta.mimeType, size: meta.size });
+            return {};
+        },
+        async get(key) {
+            const entry = store.get(key);
+            if (!entry)
+                return null;
+            const stream = new ReadableStream({
+                start(controller) {
+                    controller.enqueue(entry.data);
+                    controller.close();
+                },
+            });
+            return { stream, mimeType: entry.mimeType, size: entry.size };
+        },
+        async delete(key) {
+            store.delete(key);
+        },
+    };
+};

package/dist/{adapters → src/framework/adapters}/s3Storage.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from "../lib/storageAdapter";
+import type { StorageAdapter } from '../lib/storageAdapter';
 export interface S3StorageConfig {
     bucket: string;
     region?: string;

package/dist/{adapters → src/framework/adapters}/s3Storage.js

@@ -1,28 +1,28 @@
 function requireS3Client() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require("@aws-sdk/client-s3");
+        return require('@aws-sdk/client-s3');
     }
     catch {
-        throw new Error("@aws-sdk/client-s3 is not installed. Run: bun add @aws-sdk/client-s3");
+        throw new Error('@aws-sdk/client-s3 is not installed. Run: bun add @aws-sdk/client-s3');
     }
 }
 function requirePresigner() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require("@aws-sdk/s3-request-presigner");
+        return require('@aws-sdk/s3-request-presigner');
     }
     catch {
-        throw new Error("@aws-sdk/s3-request-presigner is not installed. Run: bun add @aws-sdk/s3-request-presigner");
+        throw new Error('@aws-sdk/s3-request-presigner is not installed. Run: bun add @aws-sdk/s3-request-presigner');
     }
 }
 function requireLibStorage() {
     try {
         // eslint-disable-next-line @typescript-eslint/no-require-imports
-        return require("@aws-sdk/lib-storage");
+        return require('@aws-sdk/lib-storage');
     }
     catch {
-        throw new Error("@aws-sdk/lib-storage is not installed. Run: bun add @aws-sdk/lib-storage");
+        throw new Error('@aws-sdk/lib-storage is not installed. Run: bun add @aws-sdk/lib-storage');
     }
 }
 export const s3Storage = (config) => {
@@ -31,7 +31,7 @@ export const s3Storage = (config) => {
         if (!_client) {
             const { S3Client } = requireS3Client();
             _client = new S3Client({
-                region: config.region ?? "us-east-1",
+                region: config.region ?? 'us-east-1',
                 ...(config.endpoint ? { endpoint: config.endpoint } : {}),
                 ...(config.credentials ? { credentials: config.credentials } : {}),
                 ...(config.forcePathStyle !== undefined ? { forcePathStyle: config.forcePathStyle } : {}),
@@ -77,9 +77,7 @@ export const s3Storage = (config) => {
                     ContentLength: meta.size,
                 }));
             }
-            const url = config.publicUrl
-                ? `${config.publicUrl.replace(/\/$/, "")}/${key}`
-                : undefined;
+            const url = config.publicUrl ? `${config.publicUrl.replace(/\/$/, '')}/${key}` : undefined;
             return { ...(url !== undefined ? { url } : {}) };
         },
         async get(key) {
@@ -95,7 +93,7 @@ export const s3Storage = (config) => {
                 };
             }
             catch (err) {
-                if (err?.name === "NoSuchKey" || err?.$metadata?.httpStatusCode === 404)
+                if (err?.name === 'NoSuchKey' || err?.$metadata?.httpStatusCode === 404)
                     return null;
                 throw err;
             }
@@ -120,7 +118,9 @@ export const s3Storage = (config) => {
             const { GetObjectCommand } = requireS3Client();
             const { getSignedUrl } = requirePresigner();
             const client = getClient();
-            return getSignedUrl(client, new GetObjectCommand({ Bucket: config.bucket, Key: key }), { expiresIn: opts.expirySeconds });
+            return getSignedUrl(client, new GetObjectCommand({ Bucket: config.bucket, Key: key }), {
+                expiresIn: opts.expirySeconds,
+            });
         },
     };
 };

package/dist/src/framework/admin/bunshotAccess.d.ts

@@ -0,0 +1,2 @@
+import type { AdminAccessProvider } from '../../../packages/bunshot-admin/src/index.js';
+export declare function createBunshotAuthAccessProvider(): AdminAccessProvider;

package/dist/src/framework/admin/bunshotAccess.js

@@ -0,0 +1,23 @@
+import { getAuthAdapter } from '../../../packages/bunshot-auth/src/lib/authAdapter';
+export function createBunshotAuthAccessProvider() {
+    return {
+        name: 'bunshot-auth',
+        async verifyRequest(c) {
+            const userId = c.get('authUserId');
+            if (!userId)
+                return null;
+            const adapter = getAuthAdapter();
+            const user = await adapter.getUser?.(userId);
+            if (!user)
+                return null;
+            const roles = (await adapter.getRoles?.(userId)) ?? [];
+            return {
+                subject: userId,
+                email: user.email,
+                displayName: user.displayName ?? undefined,
+                roles,
+                provider: 'bunshot-auth',
+            };
+        },
+    };
+}

package/dist/src/framework/admin/bunshotUsers.d.ts

@@ -0,0 +1,2 @@
+import type { ManagedUserProvider } from '../../../packages/bunshot-admin/src/index.js';
+export declare function createBunshotManagedUserProvider(): ManagedUserProvider;

package/dist/src/framework/admin/bunshotUsers.js

@@ -0,0 +1,103 @@
+import { getAuthAdapter } from '../../../packages/bunshot-auth/src/lib/authAdapter';
+import { getUserSessions, deleteUserSessions, deleteSession } from '../../../packages/bunshot-auth/src/lib/session';
+import { setSuspended } from '../../../packages/bunshot-auth/src/lib/suspension';
+export function createBunshotManagedUserProvider() {
+    return {
+        name: 'bunshot-auth',
+        async listUsers(input) {
+            const adapter = getAuthAdapter();
+            const result = await adapter.listUsers?.({
+                ...(input.search ? { email: input.search } : {}),
+                startIndex: input.offset ?? 0,
+                count: input.limit ?? 50,
+            });
+            if (!result)
+                return { items: [], total: 0 };
+            return {
+                items: result.users.map(toManagedUserRecord),
+                total: result.totalResults,
+            };
+        },
+        async getUser(userId) {
+            const adapter = getAuthAdapter();
+            const user = await adapter.getUser?.(userId);
+            if (!user)
+                return null;
+            return toManagedUserRecord({ id: userId, ...user });
+        },
+        async getCapabilities() {
+            return {
+                canListUsers: true,
+                canSearchUsers: true,
+                canViewUser: true,
+                canEditUser: true,
+                canSuspendUsers: true,
+                canDeleteUsers: true,
+                canViewSessions: true,
+                canRevokeSessions: true,
+                canManageRoles: true,
+            };
+        },
+        async suspendUser(input) {
+            await setSuspended(input.userId, true, input.reason);
+        },
+        async unsuspendUser(input) {
+            await setSuspended(input.userId, false);
+        },
+        async updateUser(input) {
+            const adapter = getAuthAdapter();
+            await adapter.updateProfile?.(input.userId, {
+                displayName: input.displayName,
+                firstName: input.firstName,
+                lastName: input.lastName,
+                externalId: input.externalId,
+            });
+            const user = await adapter.getUser?.(input.userId);
+            if (!user)
+                throw new Error(`User not found: ${input.userId}`);
+            return toManagedUserRecord({ id: input.userId, ...user });
+        },
+        async deleteUser(userId) {
+            const adapter = getAuthAdapter();
+            await deleteUserSessions(userId);
+            await adapter.deleteUser?.(userId);
+        },
+        async listSessions(userId) {
+            const sessions = await getUserSessions(userId);
+            return sessions.map(s => ({
+                sessionId: s.sessionId,
+                userId,
+                createdAt: s.createdAt,
+                lastActiveAt: s.lastActiveAt,
+                ip: s.ipAddress ?? undefined,
+                userAgent: s.userAgent ?? undefined,
+            }));
+        },
+        async revokeSession(sessionId) {
+            await deleteSession(sessionId);
+        },
+        async revokeAllSessions(userId) {
+            await deleteUserSessions(userId);
+        },
+        async getRoles(userId) {
+            const adapter = getAuthAdapter();
+            return (await adapter.getRoles?.(userId)) ?? [];
+        },
+        async setRoles(userId, roles) {
+            const adapter = getAuthAdapter();
+            await adapter.setRoles?.(userId, roles);
+        },
+    };
+}
+function toManagedUserRecord(user) {
+    return {
+        id: user.id ?? user._id?.toString(),
+        email: user.email,
+        displayName: user.displayName ?? undefined,
+        firstName: user.firstName ?? undefined,
+        lastName: user.lastName ?? undefined,
+        externalId: user.externalId ?? undefined,
+        status: user.suspended ? 'suspended' : 'active',
+        provider: 'bunshot-auth',
+    };
+}

package/dist/src/framework/admin/index.d.ts

@@ -0,0 +1,7 @@
+import { type AdminPluginConfig } from '../../../packages/bunshot-admin/src/index.js';
+import { type BunshotPlugin } from '../../../packages/bunshot-core/src/index.js';
+export interface BunshotAdminPluginConfig extends Omit<AdminPluginConfig, 'accessProvider' | 'managedUserProvider'> {
+    accessProvider?: AdminPluginConfig['accessProvider'];
+    managedUserProvider?: AdminPluginConfig['managedUserProvider'];
+}
+export declare function createBunshotAdminPlugin(config: BunshotAdminPluginConfig): BunshotPlugin;

package/dist/src/framework/admin/index.js

@@ -0,0 +1,21 @@
+import { createAdminPlugin } from '../../../packages/bunshot-admin/src/index.js';
+import { createBunshotAuthAccessProvider, createBunshotManagedUserProvider, getAuthRuntimeContext, } from '../../../packages/bunshot-auth/src/index.js';
+import { getContext } from '../../../packages/bunshot-core/src/index.js';
+export function createBunshotAdminPlugin(config) {
+    return {
+        name: 'bunshot-admin',
+        async setupRoutes(app, frameworkConfig, bus) {
+            const runtime = getAuthRuntimeContext(getContext(app));
+            const plugin = createAdminPlugin({
+                ...config,
+                accessProvider: config.accessProvider ?? createBunshotAuthAccessProvider(),
+                managedUserProvider: config.managedUserProvider ??
+                    createBunshotManagedUserProvider(runtime.adapter, runtime.config, runtime.repos.session),
+            });
+            await plugin.setupRoutes(app, frameworkConfig, bus);
+        },
+        async setup(app, frameworkConfig, bus) {
+            await this.setupRoutes(app, frameworkConfig, bus);
+        },
+    };
+}

package/dist/src/framework/boundaryAdapters/cacheFactories.d.ts

@@ -0,0 +1,13 @@
+import type { Connection } from 'mongoose';
+import { type CacheAdapter } from '../../../packages/bunshot-core/src/index.js';
+import type { StoreType } from '../../../packages/bunshot-core/src/index.js';
+export interface BoundaryCacheFactoryContext {
+    readonly redis: import('ioredis').default | null;
+    readonly mongo: Connection | null;
+    readonly sqliteDb: import('bun:sqlite').Database | null;
+}
+export type BoundaryCacheFactories = Record<StoreType, (context: BoundaryCacheFactoryContext) => Promise<CacheAdapter> | CacheAdapter>;
+export declare function createRedisBoundaryCacheAdapter(redisClient: import('ioredis').default): CacheAdapter;
+export declare function createSqliteBoundaryCacheAdapter(sqliteDb: import('bun:sqlite').Database): Promise<CacheAdapter>;
+export declare function createMongoBoundaryCacheAdapter(appConnection: Connection): Promise<CacheAdapter>;
+export declare const boundaryCacheFactories: BoundaryCacheFactories;

package/dist/src/framework/boundaryAdapters/cacheFactories.js

@@ -0,0 +1,86 @@
+import { createMemoryCacheAdapter } from '../../../packages/bunshot-core/src/index.js';
+export function createRedisBoundaryCacheAdapter(redisClient) {
+    return {
+        name: 'redis',
+        async get(key) {
+            return redisClient.get(key);
+        },
+        async set(key, value, ttl) {
+            if (ttl) {
+                await redisClient.setex(key, ttl, value);
+                return;
+            }
+            await redisClient.set(key, value);
+        },
+        async del(key) {
+            await redisClient.del(key);
+        },
+        async delPattern(pattern) {
+            let cursor = '0';
+            do {
+                const [next, keys] = await redisClient.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                cursor = next;
+                if (keys.length > 0) {
+                    await redisClient.del(...keys);
+                }
+            } while (cursor !== '0');
+        },
+        isReady() {
+            return true;
+        },
+    };
+}
+export async function createSqliteBoundaryCacheAdapter(sqliteDb) {
+    const { createSqliteCacheAdapter } = await import('../../../packages/bunshot-auth/src/lib/cache');
+    return createSqliteCacheAdapter(sqliteDb);
+}
+export async function createMongoBoundaryCacheAdapter(appConnection) {
+    const { getCacheModel } = await import('../middleware/cacheResponse');
+    const cacheModel = getCacheModel(appConnection);
+    return {
+        name: 'mongo',
+        async get(key) {
+            const doc = await cacheModel.findOne({ key }, 'value').lean();
+            return doc ? doc.value : null;
+        },
+        async set(key, value, ttl) {
+            const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : undefined;
+            await cacheModel.updateOne({ key }, { $set: { value, ...(expiresAt ? { expiresAt } : {}) } }, { upsert: true });
+        },
+        async del(key) {
+            await cacheModel.deleteOne({ key });
+        },
+        async delPattern(pattern) {
+            const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+            const regex = new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+            await cacheModel.deleteMany({ key: regex });
+        },
+        isReady() {
+            return appConnection.readyState === 1;
+        },
+    };
+}
+export const boundaryCacheFactories = {
+    memory: () => createMemoryCacheAdapter(),
+    redis: context => {
+        if (!context.redis) {
+            throw new Error('[framework/boundaryAdapters] Redis cache adapter requested without a Redis client');
+        }
+        return createRedisBoundaryCacheAdapter(context.redis);
+    },
+    sqlite: context => {
+        if (!context.sqliteDb) {
+            throw new Error('[framework/boundaryAdapters] SQLite cache adapter requested without a SQLite database');
+        }
+        return createSqliteBoundaryCacheAdapter(context.sqliteDb);
+    },
+    mongo: context => {
+        if (!context.mongo) {
+            throw new Error('[framework/boundaryAdapters] Mongo cache adapter requested without a Mongo connection');
+        }
+        return createMongoBoundaryCacheAdapter(context.mongo);
+    },
+    // TODO: implement a native postgres cache adapter.
+    // For now postgres deployments fall back to in-memory (single-process only).
+    postgres: () => createMemoryCacheAdapter(),
+};

package/dist/src/framework/boundaryAdapters/index.d.ts

@@ -0,0 +1,2 @@
+export { boundaryCacheFactories, createMongoBoundaryCacheAdapter, createRedisBoundaryCacheAdapter, createSqliteBoundaryCacheAdapter, } from './cacheFactories';
+export type { BoundaryCacheFactories, BoundaryCacheFactoryContext } from './cacheFactories';

package/dist/src/framework/boundaryAdapters/index.js

@@ -0,0 +1 @@
+export { boundaryCacheFactories, createMongoBoundaryCacheAdapter, createRedisBoundaryCacheAdapter, createSqliteBoundaryCacheAdapter, } from './cacheFactories';

package/dist/src/framework/boundaryAdapters.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cache adapter factories for each framework store type.
+ *
+ * Used by registerBoundaryAdapters to resolve the appropriate cache adapter
+ * based on which backends are available.
+ */
+import type { CacheAdapter } from '../../packages/bunshot-core/src/index.js';
+import type { FrameworkStoreType } from './persistence/storeInfra';
+import type { Connection } from 'mongoose';
+export interface CacheFactoryContext {
+    redis: import('ioredis').default | null;
+    mongo: Connection | null;
+    sqliteDb: import('bun:sqlite').Database | null;
+}
+type CacheFactory = (ctx: CacheFactoryContext) => CacheAdapter | Promise<CacheAdapter>;
+export declare const boundaryCacheFactories: Record<FrameworkStoreType, CacheFactory>;
+export {};

package/dist/src/framework/boundaryAdapters.js

@@ -0,0 +1,62 @@
+/**
+ * Cache adapter factories for each framework store type.
+ *
+ * Used by registerBoundaryAdapters to resolve the appropriate cache adapter
+ * based on which backends are available.
+ */
+import { createMemoryCacheAdapter } from '../../packages/bunshot-core/src/index.js';
+export const boundaryCacheFactories = {
+    memory: () => createMemoryCacheAdapter(),
+    sqlite: (ctx) => {
+        const { createSqliteCacheAdapter } = require('../../packages/bunshot-auth/src/lib/cache');
+        return createSqliteCacheAdapter(ctx.sqliteDb);
+    },
+    redis: (ctx) => {
+        const redisClient = ctx.redis;
+        return {
+            name: 'redis',
+            async get(key) { return redisClient.get(key); },
+            async set(key, value, ttl) {
+                if (ttl) {
+                    await redisClient.setex(key, ttl, value);
+                }
+                else {
+                    await redisClient.set(key, value);
+                }
+            },
+            async del(key) { await redisClient.del(key); },
+            async delPattern(pattern) {
+                let cursor = '0';
+                do {
+                    const [next, keys] = await redisClient.scan(cursor, 'MATCH', pattern, 'COUNT', 100);
+                    cursor = next;
+                    if (keys.length > 0)
+                        await redisClient.del(...keys);
+                } while (cursor !== '0');
+            },
+            isReady() { return true; },
+        };
+    },
+    mongo: async (ctx) => {
+        const { getCacheModel } = await import('./middleware/cacheResponse');
+        const cacheModel = getCacheModel(ctx.mongo);
+        return {
+            name: 'mongo',
+            async get(key) {
+                const doc = await cacheModel.findOne({ key }, 'value').lean();
+                return doc ? doc.value : null;
+            },
+            async set(key, value, ttl) {
+                const expiresAt = ttl ? new Date(Date.now() + ttl * 1000) : undefined;
+                await cacheModel.updateOne({ key }, { $set: { value, ...(expiresAt ? { expiresAt } : {}) } }, { upsert: true });
+            },
+            async del(key) { await cacheModel.deleteOne({ key }); },
+            async delPattern(pattern) {
+                const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+                const regex = new RegExp('^' + escaped.replace(/\*/g, '.*') + '$');
+                await cacheModel.deleteMany({ key: regex });
+            },
+            isReady() { return ctx.mongo.readyState === 1; },
+        };
+    },
+};

package/dist/src/framework/buildContext.d.ts

@@ -0,0 +1,33 @@
+/**
+ * BunshotContext assembly — extracted from createApp().
+ *
+ * Constructs the immutable context object that is attached to the Hono app and
+ * accessible from all middleware and route handlers via c.get('bunshotCtx').
+ * Also owns the clear() and destroy() lifecycle methods.
+ */
+import type { InfrastructureResult } from './createInfrastructure';
+import type { MetricsState } from './lib/metrics';
+import type { UploadConfig } from './mountOptionalEndpoints';
+import type { ResolvedSecretBundle } from './secrets/resolveSecretBundle';
+import type { OpenAPIHono } from '@hono/zod-openapi';
+import type { SigningConfig } from '../lib/signingConfig';
+import type { BunshotContext, BunshotEventBus, BunshotPlugin, CaptchaConfig, CoreRegistrarSnapshot } from '../../packages/bunshot-core/src/index.js';
+import type { AppEnv } from '../../packages/bunshot-core/src/index.js';
+export interface BuildContextParams {
+    app: OpenAPIHono<AppEnv>;
+    appName: string;
+    infra: InfrastructureResult;
+    signing: SigningConfig | null | undefined;
+    captcha: CaptchaConfig | null | undefined;
+    upload: UploadConfig | undefined;
+    metricsState: MetricsState;
+    plugins: readonly BunshotPlugin[];
+    bus: BunshotEventBus;
+    secretBundle: ResolvedSecretBundle;
+}
+/**
+ * Apply the drain() snapshot to the context after all plugin phases complete.
+ * Replaces the mutable cast pattern in createApp() — single internal mutation point.
+ */
+export declare function finalizeContext(ctx: BunshotContext, snapshot: CoreRegistrarSnapshot): void;
+export declare function buildContext(params: BuildContextParams): BunshotContext;