@webstir-io/webstir-backend 0.1.15 → 0.1.16

package/dist/deploy-cli.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+import path from 'node:path';
+import { startPublishedWorkspaceServer } from './runtime/deploy.js';
+async function main(argv) {
+    const args = parseArgs(argv);
+    if (args.help) {
+        printHelp();
+        return;
+    }
+    const workspaceRoot = path.resolve(args.workspace ?? process.cwd());
+    const server = await startPublishedWorkspaceServer({
+        workspaceRoot,
+        host: args.host,
+        port: args.port,
+    });
+    const shutdown = async (signal) => {
+        process.stderr.write(`[webstir-backend-deploy] received ${signal}, stopping.\n`);
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown('SIGINT'));
+    process.on('SIGTERM', () => void shutdown('SIGTERM'));
+    process.stdout.write(`[webstir-backend-deploy] serving ${server.mode} workspace at ${server.origin}\n`);
+    await new Promise(() => {
+        // Keep the process alive until it receives a signal.
+    });
+}
+function parseArgs(argv) {
+    let workspace;
+    let host;
+    let port;
+    let help = false;
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
+        if (arg === '--workspace') {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error('Missing value for --workspace.');
+            }
+            workspace = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--host') {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error('Missing value for --host.');
+            }
+            host = next;
+            index += 1;
+            continue;
+        }
+        if (arg === '--port') {
+            const next = argv[index + 1];
+            if (!next) {
+                throw new Error('Missing value for --port.');
+            }
+            const parsed = Number(next);
+            if (!Number.isInteger(parsed) || parsed <= 0) {
+                throw new Error(`Invalid value for --port: ${next}`);
+            }
+            port = parsed;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    return { workspace, host, port, help };
+}
+function printHelp() {
+    process.stdout.write(`Usage: webstir-backend-deploy [--workspace <path>] [--host <host>] [--port <port>]
+
+Starts a published api or full Webstir workspace with a single Bun entrypoint.
+`);
+}
+main(process.argv.slice(2)).catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+});

package/dist/diagnostics/summary.js

@@ -1,11 +1,11 @@
 export function pushEntryBucketSummary(diagnostics, entryPoints) {
     try {
-        const server = entryPoints.filter((p) => p === 'index.js' || /(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p)).length;
+        const server = entryPoints.filter((p) => p === 'index.js' || (/(^|\/)index\.js$/.test(p) && !/^(functions|jobs)\//.test(p))).length;
         const functionsCount = entryPoints.filter((p) => p.startsWith('functions/')).length;
         const jobsCount = entryPoints.filter((p) => p.startsWith('jobs/')).length;
         diagnostics.push({
             severity: 'info',
-            message: `[webstir-backend] entries by bucket: server=${server} functions=${functionsCount} jobs=${jobsCount}`
+            message: `[webstir-backend] entries by bucket: server=${server} functions=${functionsCount} jobs=${jobsCount}`,
         });
     }
     catch {

package/dist/index.d.ts

@@ -1,2 +1,8 @@
+export { runAddJob, runAddRoute, runUpdateRouteContract } from './add.js';
+export type { AddJobOptions, AddRouteOptions, UpdateRouteContractOptions } from './add.js';
 export { backendProvider } from './provider.js';
 export { startBackendWatch } from './watch.js';
+export { getBackendScaffoldAssets } from './scaffold/assets.js';
+export { createDefaultBunBackendBootstrap, startBunBackend } from './runtime/bun.js';
+export type { BunRuntimeEnvLike, DefaultBunBackendBootstrapOptions, MetricsTracker, RuntimeLogger, } from './runtime/bun.js';
+export { startPublishedWorkspaceServer } from './runtime/deploy.js';

package/dist/index.js

@@ -1,2 +1,6 @@
+export { runAddJob, runAddRoute, runUpdateRouteContract } from './add.js';
 export { backendProvider } from './provider.js';
 export { startBackendWatch } from './watch.js';
+export { getBackendScaffoldAssets } from './scaffold/assets.js';
+export { createDefaultBunBackendBootstrap, startBunBackend } from './runtime/bun.js';
+export { startPublishedWorkspaceServer } from './runtime/deploy.js';

package/dist/manifest/pipeline.js

@@ -1,14 +1,14 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
 import { pathToFileURL } from 'node:url';
 import { moduleManifestSchema, CONTRACT_VERSION } from '@webstir-io/module-contract';
+import { readTextFile } from '../utils/bun.js';
 export async function loadBackendModuleManifest(options) {
     const { workspaceRoot, buildRoot, entryPoints, diagnostics } = options;
     const pkgPath = path.join(workspaceRoot, 'package.json');
     let workspacePackage;
     try {
-        const raw = await readFile(pkgPath, 'utf8');
+        const raw = await readTextFile(pkgPath);
         workspacePackage = JSON.parse(raw);
     }
     catch (error) {
@@ -17,15 +17,21 @@ export async function loadBackendModuleManifest(options) {
         if (err.code !== 'ENOENT') {
             diagnostics.push({
                 severity: 'warn',
-                message: `[webstir-backend] unable to read ${pkgPath}: ${err.message}. Using defaults.`
+                message: `[webstir-backend] unable to read ${pkgPath}: ${err.message}. Using defaults.`,
             });
         }
     }
     const moduleConfig = workspacePackage?.webstir?.moduleManifest ?? {};
     let manifestCandidate = {
-        contractVersion: typeof moduleConfig.contractVersion === 'string' ? moduleConfig.contractVersion : CONTRACT_VERSION,
-        name: typeof moduleConfig.name === 'string' ? moduleConfig.name : deriveModuleName(workspacePackage, workspaceRoot),
-        version: typeof moduleConfig.version === 'string' ? moduleConfig.version : deriveModuleVersion(workspacePackage),
+        contractVersion: typeof moduleConfig.contractVersion === 'string'
+            ? moduleConfig.contractVersion
+            : CONTRACT_VERSION,
+        name: typeof moduleConfig.name === 'string'
+            ? moduleConfig.name
+            : deriveModuleName(workspacePackage, workspaceRoot),
+        version: typeof moduleConfig.version === 'string'
+            ? moduleConfig.version
+            : deriveModuleVersion(workspacePackage),
         kind: 'backend',
         capabilities: Array.isArray(moduleConfig.capabilities) ? moduleConfig.capabilities : [],
         routes: moduleConfig.routes ?? [],
@@ -34,25 +40,28 @@ export async function loadBackendModuleManifest(options) {
         events: moduleConfig.events ?? [],
         services: moduleConfig.services ?? [],
         init: moduleConfig.init,
-        dispose: moduleConfig.dispose
+        dispose: moduleConfig.dispose,
     };
     const definition = await loadModuleDefinition(buildRoot, diagnostics);
     if (definition) {
         const definitionManifest = definition.manifest ?? {};
         const routesFromDefinition = definition.routes?.map((route) => route.definition);
         const viewsFromDefinition = definition.views?.map((view) => view.definition);
-        const mergedCapabilities = Array.from(new Set([...(manifestCandidate.capabilities ?? []), ...(definitionManifest.capabilities ?? [])]));
+        const mergedCapabilities = Array.from(new Set([
+            ...(manifestCandidate.capabilities ?? []),
+            ...(definitionManifest.capabilities ?? []),
+        ]));
         manifestCandidate = {
             ...manifestCandidate,
             ...definitionManifest,
             capabilities: mergedCapabilities,
-            routes: routesFromDefinition ?? definitionManifest.routes ?? manifestCandidate.routes ?? [],
+            routes: mergeRouteDefinitions(routesFromDefinition ?? definitionManifest.routes, manifestCandidate.routes),
             views: viewsFromDefinition ?? definitionManifest.views ?? manifestCandidate.views ?? [],
-            jobs: definitionManifest.jobs ?? manifestCandidate.jobs ?? [],
+            jobs: mergeJobDefinitions(definitionManifest.jobs, manifestCandidate.jobs),
             events: definitionManifest.events ?? manifestCandidate.events ?? [],
             services: definitionManifest.services ?? manifestCandidate.services ?? [],
             init: definitionManifest.init ?? manifestCandidate.init,
-            dispose: definitionManifest.dispose ?? manifestCandidate.dispose
+            dispose: definitionManifest.dispose ?? manifestCandidate.dispose,
         };
     }
     const validation = moduleManifestSchema.safeParse(manifestCandidate);
@@ -62,7 +71,7 @@ export async function loadBackendModuleManifest(options) {
             .join('; ');
         diagnostics.push({
             severity: 'error',
-            message: `[webstir-backend] module manifest validation failed (${problems}). Falling back to defaults.`
+            message: `[webstir-backend] module manifest validation failed (${problems}). Falling back to defaults.`,
         });
         return {
             contractVersion: CONTRACT_VERSION,
@@ -74,7 +83,7 @@ export async function loadBackendModuleManifest(options) {
             views: [],
             jobs: [],
             events: [],
-            services: []
+            services: [],
         };
     }
     const manifest = validation.data;
@@ -82,23 +91,26 @@ export async function loadBackendModuleManifest(options) {
         const normalizePath = (p) => {
             let s = typeof p === 'string' ? p : '';
             if (!s.startsWith('/'))
-                s = '/' + s;
+                s = `/${s}`;
             s = s.replace(/\/+/, '/');
             if (s.length > 1 && s.endsWith('/'))
                 s = s.slice(0, -1);
             return s;
         };
         const seen = new Map();
-        for (const r of manifest.routes ?? []) {
-            const method = typeof r.method === 'string' ? r.method.toUpperCase() : '';
-            const pathKey = normalizePath(r.path);
+        for (const route of (manifest.routes ?? [])) {
+            const method = typeof route.method === 'string' ? route.method.toUpperCase() : '';
+            const pathKey = normalizePath(route.path);
             const key = `${method} ${pathKey}`;
             seen.set(key, (seen.get(key) ?? 0) + 1);
         }
         const dups = Array.from(seen.entries()).filter(([, count]) => count > 1);
         if (dups.length > 0) {
             const list = dups.map(([k, c]) => `${k} (${c}x)`).join(', ');
-            diagnostics.push({ severity: 'warn', message: `[webstir-backend] duplicate route definitions: ${list}` });
+            diagnostics.push({
+                severity: 'warn',
+                message: `[webstir-backend] duplicate route definitions: ${list}`,
+            });
         }
     }
     catch {
@@ -107,7 +119,7 @@ export async function loadBackendModuleManifest(options) {
     if (manifest.routes?.length && entryPoints.length === 0) {
         diagnostics.push({
             severity: 'warn',
-            message: '[webstir-backend] module manifest defines routes but no entry points were built. Ensure backend compilation produced handlers.'
+            message: '[webstir-backend] module manifest defines routes but no entry points were built. Ensure backend compilation produced handlers.',
         });
     }
     try {
@@ -117,17 +129,20 @@ export async function loadBackendModuleManifest(options) {
         if (jobs.length + events.length + services.length > 0) {
             diagnostics.push({
                 severity: 'info',
-                message: `[webstir-backend] manifest jobs=${jobs.length} events=${events.length} services=${services.length}`
+                message: `[webstir-backend] manifest jobs=${jobs.length} events=${events.length} services=${services.length}`,
             });
         }
-        const noSchedule = jobs.filter((j) => j && typeof j.name === 'string' && (j.schedule === undefined || j.schedule === null));
+        const noSchedule = jobs.filter((job) => typeof job.name === 'string' && (job.schedule === undefined || job.schedule === null));
         if (noSchedule.length > 0) {
             const MAX_LIST = 10;
-            const names = noSchedule.map((j) => j.name).slice(0, MAX_LIST).join(', ');
+            const names = noSchedule
+                .map((job) => job.name)
+                .slice(0, MAX_LIST)
+                .join(', ');
             const omitted = noSchedule.length > MAX_LIST ? ` (+${noSchedule.length - MAX_LIST} more)` : '';
             diagnostics.push({
                 severity: 'warn',
-                message: `[webstir-backend] jobs without schedules: ${names}${omitted}`
+                message: `[webstir-backend] jobs without schedules: ${names}${omitted}`,
             });
         }
     }
@@ -137,8 +152,13 @@ export async function loadBackendModuleManifest(options) {
     try {
         const routes = Array.isArray(manifest.routes) ? manifest.routes.length : 0;
         const views = Array.isArray(manifest.views) ? manifest.views.length : 0;
-        const caps = Array.isArray(manifest.capabilities) && manifest.capabilities.length > 0 ? ` [${manifest.capabilities.join(', ')}]` : '';
-        diagnostics.push({ severity: 'info', message: `[webstir-backend] manifest routes=${routes} views=${views}${caps}` });
+        const caps = Array.isArray(manifest.capabilities) && manifest.capabilities.length > 0
+            ? ` [${manifest.capabilities.join(', ')}]`
+            : '';
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] manifest routes=${routes} views=${views}${caps}`,
+        });
     }
     catch {
         // ignore
@@ -150,7 +170,7 @@ async function loadModuleDefinition(buildRoot, diagnostics) {
         path.join(buildRoot, 'module.js'),
         path.join(buildRoot, 'module.mjs'),
         path.join(buildRoot, 'module/index.js'),
-        path.join(buildRoot, 'module/index.mjs')
+        path.join(buildRoot, 'module/index.mjs'),
     ];
     for (const fullPath of candidates) {
         if (!existsSync(fullPath)) {
@@ -165,13 +185,13 @@ async function loadModuleDefinition(buildRoot, diagnostics) {
             }
             diagnostics.push({
                 severity: 'warn',
-                message: `[webstir-backend] module definition at ${fullPath} does not export a createModule() definition.`
+                message: `[webstir-backend] module definition at ${fullPath} does not export a createModule() definition.`,
             });
         }
         catch (error) {
             diagnostics.push({
                 severity: 'warn',
-                message: `[webstir-backend] failed to load module definition from ${fullPath}: ${error.message}`
+                message: `[webstir-backend] failed to load module definition from ${fullPath}: ${error.message}`,
             });
         }
     }
@@ -190,10 +210,11 @@ function extractModuleDefinition(exports) {
     return undefined;
 }
 function isModuleDefinition(value) {
-    return typeof value === 'object' && value !== null && 'manifest' in value;
+    return (typeof value === 'object' && value !== null && 'manifest' in value);
 }
 function deriveModuleName(pkg, workspaceRoot) {
-    if (typeof pkg?.webstir?.moduleManifest?.name === 'string' && pkg.webstir.moduleManifest.name.length > 0) {
+    if (typeof pkg?.webstir?.moduleManifest?.name === 'string' &&
+        pkg.webstir.moduleManifest.name.length > 0) {
         return pkg.webstir.moduleManifest.name;
     }
     if (typeof pkg?.name === 'string' && pkg.name.length > 0) {
@@ -202,7 +223,8 @@ function deriveModuleName(pkg, workspaceRoot) {
     return `backend-module-${path.basename(workspaceRoot)}`;
 }
 function deriveModuleVersion(pkg) {
-    if (typeof pkg?.webstir?.moduleManifest?.version === 'string' && pkg.webstir.moduleManifest.version.length > 0) {
+    if (typeof pkg?.webstir?.moduleManifest?.version === 'string' &&
+        pkg.webstir.moduleManifest.version.length > 0) {
         return pkg.webstir.moduleManifest.version;
     }
     if (typeof pkg?.version === 'string' && pkg.version.length > 0) {
@@ -210,6 +232,55 @@ function deriveModuleVersion(pkg) {
     }
     return '0.0.0';
 }
+function mergeRouteDefinitions(definitionRoutes, packageRoutes) {
+    const merged = Array.isArray(definitionRoutes) ? [...definitionRoutes] : [];
+    const seen = new Set(merged.map((route) => getRouteKey(route)).filter(Boolean));
+    for (const route of packageRoutes ?? []) {
+        const key = getRouteKey(route);
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        merged.push(route);
+        seen.add(key);
+    }
+    return merged;
+}
+function mergeJobDefinitions(definitionJobs, packageJobs) {
+    const merged = Array.isArray(definitionJobs) ? [...definitionJobs] : [];
+    const seen = new Set(merged.map((job) => getJobKey(job)).filter(Boolean));
+    for (const job of packageJobs ?? []) {
+        const key = getJobKey(job);
+        if (!key || seen.has(key)) {
+            continue;
+        }
+        merged.push(job);
+        seen.add(key);
+    }
+    return merged;
+}
+function getJobKey(job) {
+    return typeof job?.name === 'string' && job.name.length > 0 ? job.name : undefined;
+}
+function getRouteKey(route) {
+    const method = typeof route?.method === 'string' ? route.method.toUpperCase() : '';
+    const routePath = normalizeRoutePath(route?.path);
+    if (!method || !routePath) {
+        return undefined;
+    }
+    return `${method} ${routePath}`;
+}
+function normalizeRoutePath(routePath) {
+    if (typeof routePath !== 'string' || routePath.length === 0) {
+        return undefined;
+    }
+    let normalized = routePath;
+    if (!normalized.startsWith('/'))
+        normalized = `/${normalized}`;
+    normalized = normalized.replace(/\/+/g, '/');
+    if (normalized.length > 1 && normalized.endsWith('/'))
+        normalized = normalized.slice(0, -1);
+    return normalized;
+}
 export async function summarizeBuiltManifest(buildRoot) {
     const definition = await loadModuleDefinition(buildRoot, []);
     if (!definition || !definition.manifest) {
@@ -219,6 +290,6 @@ export async function summarizeBuiltManifest(buildRoot) {
     return {
         routes: Array.isArray(manifest.routes) ? manifest.routes.length : 0,
         views: Array.isArray(manifest.views) ? manifest.views.length : 0,
-        capabilities: manifest.capabilities
+        capabilities: manifest.capabilities,
     };
 }

package/dist/provider.js

@@ -1,12 +1,12 @@
 import path from 'node:path';
 import { existsSync } from 'node:fs';
 import { collectArtifacts, createBuildManifest } from './build/artifacts.js';
-import { buildSupportFile, runBackendBuildPipeline } from './build/pipeline.js';
+import { buildSupportFile, resolveBackendBundler, runBackendBuildPipeline, } from './build/pipeline.js';
 import { loadBackendModuleManifest } from './manifest/pipeline.js';
 import { createCacheReporter } from './cache/reporters.js';
 import { normalizeLogLevel, filterDiagnostics } from './diagnostics/summary.js';
 import { getBackendScaffoldAssets } from './scaffold/assets.js';
-import { normalizeMode, resolveWorkspacePaths } from './workspace.js';
+import { normalizeMode, resolveWorkspacePaths, resolveWorkspaceRoot } from './workspace.js';
 import packageJson from '../package.json' with { type: 'json' };
 const pkg = packageJson;
 export const backendProvider = {
@@ -16,19 +16,32 @@ export const backendProvider = {
         version: pkg.version ?? '0.0.0',
         compatibility: {
             minCliVersion: '0.1.0',
-            nodeRange: pkg.engines?.node ?? '>=20.18.1'
-        }
+            nodeRange: pkg.engines?.node ?? '>=20.18.1',
+            ...(pkg.engines?.bun ? { notes: `Requires Bun ${pkg.engines.bun} at runtime.` } : {}),
+        },
     },
     resolveWorkspace(options) {
-        return resolveWorkspacePaths(options.workspaceRoot);
+        const workspaceRoot = resolveWorkspaceRoot({
+            workspaceRoot: options.workspaceRoot,
+        });
+        return resolveWorkspacePaths(workspaceRoot);
     },
     async build(options) {
-        const paths = resolveWorkspacePaths(options.workspaceRoot);
+        const env = options.env ?? {};
+        const workspaceRoot = resolveWorkspaceRoot({
+            workspaceRoot: options.workspaceRoot,
+            env,
+        });
+        const paths = resolveWorkspacePaths(workspaceRoot);
         const tsconfigPath = path.join(paths.sourceRoot, 'tsconfig.json');
         const diagnostics = [];
         const incremental = options.incremental === true;
-        const env = options.env ?? {};
         const mode = normalizeMode(env.WEBSTIR_MODULE_MODE);
+        const bundler = resolveBackendBundler({
+            env,
+            incremental,
+            diagnostics,
+        });
         console.info(`[webstir-backend] ${mode}:start`);
         const { entryPoints, outputs, includePublishSourcemaps } = await runBackendBuildPipeline({
             sourceRoot: paths.sourceRoot,
@@ -37,7 +50,8 @@ export const backendProvider = {
             mode,
             env,
             incremental,
-            diagnostics
+            diagnostics,
+            bundler,
         });
         const artifacts = await collectArtifacts(paths.buildRoot, includePublishSourcemaps);
         const envSource = path.join(paths.sourceRoot, 'env.ts');
@@ -50,7 +64,8 @@ export const backendProvider = {
                     tsconfigPath,
                     mode,
                     env,
-                    diagnostics
+                    diagnostics,
+                    bundler,
                 });
             }
             catch {
@@ -58,19 +73,22 @@ export const backendProvider = {
             }
         }
         const moduleManifest = await loadBackendModuleManifest({
-            workspaceRoot: options.workspaceRoot,
+            workspaceRoot,
             buildRoot: paths.buildRoot,
             entryPoints,
-            diagnostics
+            diagnostics,
         });
         const manifest = createBuildManifest(paths.buildRoot, artifacts, diagnostics, moduleManifest);
         console.info(`[webstir-backend] ${mode}:complete (entries=${manifest.entryPoints.length})`);
-        diagnostics.push({ severity: 'info', message: `[webstir-backend] ${mode}:built entries=${manifest.entryPoints.length}` });
+        diagnostics.push({
+            severity: 'info',
+            message: `[webstir-backend] ${mode}:built entries=${manifest.entryPoints.length}`,
+        });
         const cacheReporter = createCacheReporter({
-            workspaceRoot: options.workspaceRoot,
+            workspaceRoot,
             buildRoot: paths.buildRoot,
             env,
-            diagnostics
+            diagnostics,
         });
         try {
             await cacheReporter.diffOutputs(outputs, mode);
@@ -91,11 +109,11 @@ export const backendProvider = {
             artifacts,
             manifest: {
                 ...manifest,
-                diagnostics: filteredDiagnostics
-            }
+                diagnostics: filteredDiagnostics,
+            },
         };
     },
     async getScaffoldAssets() {
         return await getBackendScaffoldAssets();
-    }
+    },
 };

package/dist/runtime/bun.d.ts

@@ -0,0 +1,51 @@
+import { type SessionCookieConfig, type SessionStore } from './session.js';
+export type { RouteHandlerResult } from './core.js';
+export interface RuntimeLogger {
+    child(bindings: Record<string, unknown>): RuntimeLogger;
+    info(value: unknown, message?: string): void;
+    warn(value: unknown, message?: string): void;
+    error(value: unknown, message?: string): void;
+}
+export interface MetricsTracker {
+    record(metric: {
+        method: string;
+        route: string;
+        status: number;
+        durationMs: number;
+    }): void;
+    snapshot(): unknown;
+}
+export interface BunRuntimeEnvLike<TAuthConfig = unknown, TMetricsConfig = unknown> {
+    NODE_ENV: string;
+    PORT: number;
+    auth: TAuthConfig;
+    metrics: TMetricsConfig;
+    http: {
+        bodyLimitBytes: number;
+    };
+    sessions: SessionCookieConfig;
+}
+export interface BunRuntimeBootstrapOptions<TEnv extends BunRuntimeEnvLike = BunRuntimeEnvLike, TLogger extends RuntimeLogger = RuntimeLogger, TSession extends Record<string, unknown> = Record<string, unknown>, TAuth = unknown, TMetricsTracker extends MetricsTracker = MetricsTracker> {
+    importMetaUrl: string;
+    moduleCandidates?: readonly string[];
+    loadEnv(): TEnv;
+    resolveWorkspaceRoot(): string;
+    resolveRequestAuth(request: Request, auth: TEnv['auth'], logger?: {
+        warn?(message: string, metadata?: Record<string, unknown>): void;
+    }): Promise<TAuth | undefined>;
+    createBaseLogger(env: TEnv): TLogger;
+    createMetricsTracker(config: TEnv['metrics']): TMetricsTracker;
+    sessionStore: SessionStore<TSession>;
+}
+export interface DefaultBunBackendBootstrapOptions<TEnv extends BunRuntimeEnvLike = BunRuntimeEnvLike, TLogger extends RuntimeLogger = RuntimeLogger, TSession extends Record<string, unknown> = Record<string, unknown>, TAuth = unknown, TMetricsTracker extends MetricsTracker = MetricsTracker> {
+    importMetaUrl: string;
+    loadEnv(): TEnv;
+    moduleCandidates?: readonly string[];
+    resolveWorkspaceRoot?: () => string;
+    resolveRequestAuth?: BunRuntimeBootstrapOptions<TEnv, TLogger, TSession, TAuth, TMetricsTracker>['resolveRequestAuth'];
+    createBaseLogger?: (env: TEnv) => TLogger;
+    createMetricsTracker?: (config: TEnv['metrics']) => TMetricsTracker;
+    sessionStore?: SessionStore<TSession>;
+}
+export declare function startBunBackend<TEnv extends BunRuntimeEnvLike, TLogger extends RuntimeLogger, TSession extends Record<string, unknown>, TAuth, TMetricsTracker extends MetricsTracker>(options: BunRuntimeBootstrapOptions<TEnv, TLogger, TSession, TAuth, TMetricsTracker>): Promise<void>;
+export declare function createDefaultBunBackendBootstrap<TEnv extends BunRuntimeEnvLike, TLogger extends RuntimeLogger = RuntimeLogger, TSession extends Record<string, unknown> = Record<string, unknown>, TAuth = unknown, TMetricsTracker extends MetricsTracker = MetricsTracker>(options: DefaultBunBackendBootstrapOptions<TEnv, TLogger, TSession, TAuth, TMetricsTracker>): BunRuntimeBootstrapOptions<TEnv, TLogger, TSession, TAuth, TMetricsTracker>;