@zintrust/core 0.1.0

package/src/routing/Router.js

@@ -0,0 +1,191 @@
+export const createRouter = () => ({
+    routes: [],
+    prefix: '',
+    routeIndex: new Map(),
+});
+/**
+ * Router - HTTP Routing Engine
+ * Matches incoming requests to route handlers
+ */
+/**
+ * Convert a path pattern to a regex
+ * Example: /users/:id/posts/:postId -> /users/([^/]+)/posts/([^/]+)
+ */
+const pathToRegex = (path) => {
+    const paramNames = [];
+    let regexPath = path.replaceAll(/:([a-zA-Z_]\w*)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '([^/]+)';
+    });
+    regexPath = `^${regexPath}$`;
+    const pattern = new RegExp(regexPath);
+    return { pattern, paramNames };
+};
+/**
+ * Register a route
+ */
+const registerRoute = (router, method, path, handler) => {
+    const { pattern, paramNames } = pathToRegex(path);
+    const route = {
+        method,
+        path,
+        pattern,
+        handler,
+        paramNames,
+    };
+    router.routes.push(route);
+    // Index by method for faster lookup
+    if (!router.routeIndex.has(method)) {
+        router.routeIndex.set(method, []);
+    }
+    router.routeIndex.get(method)?.push(route);
+};
+/**
+ * Extract parameters from a matching route
+ */
+const getRouteMatch = (route, path) => {
+    const match = route.pattern.exec(path);
+    if (!match)
+        return null;
+    const params = {};
+    route.paramNames.forEach((paramName, index) => {
+        params[paramName] = match[index + 1];
+    });
+    return {
+        handler: route.handler,
+        params,
+    };
+};
+/**
+ * Fallback linear search for manually added routes
+ */
+const findInFallback = (router, method, path) => {
+    for (const route of router.routes) {
+        // Skip if already checked via index
+        if (router.routeIndex !== undefined) {
+            const methodRoutes = router.routeIndex.get(route.method);
+            if (methodRoutes?.includes(route) ?? false)
+                continue;
+        }
+        if (route.method !== method && route.method !== '*')
+            continue;
+        const match = getRouteMatch(route, path);
+        if (match)
+            return match;
+    }
+    return null;
+};
+/**
+ * Match a request to a route
+ */
+const matchRoute = (router, method, path) => {
+    // Try fast lookup first
+    if (router.routeIndex !== undefined) {
+        const candidates = [
+            ...(router.routeIndex.get(method) ?? []),
+            ...(router.routeIndex.get('*') ?? []),
+        ];
+        for (const route of candidates) {
+            const match = getRouteMatch(route, path);
+            if (match)
+                return match;
+        }
+    }
+    // Fallback to linear search for manually added routes or if index is missing
+    return findInFallback(router, method, path);
+};
+const stripTrailingSlashes = (value) => {
+    let end = value.length;
+    while (end > 0 && value.codePointAt(end - 1) === 47) {
+        end--;
+    }
+    return value.slice(0, end);
+};
+const normalizePrefix = (prefix) => {
+    const trimmed = prefix.trim();
+    if (trimmed === '' || trimmed === '/')
+        return '';
+    const withoutTrailing = stripTrailingSlashes(trimmed);
+    return withoutTrailing.startsWith('/') ? withoutTrailing : `/${withoutTrailing}`;
+};
+const normalizePath = (path) => {
+    const trimmed = path.trim();
+    if (trimmed === '')
+        return '/';
+    return trimmed.startsWith('/') ? trimmed : `/${trimmed}`;
+};
+const joinPaths = (prefix, path) => {
+    const pfx = normalizePrefix(prefix);
+    const pth = normalizePath(path);
+    if (pfx === '')
+        return pth;
+    if (pth === '/')
+        return pfx || '/';
+    return `${pfx}${pth}`;
+};
+const scopeRouter = (router, prefix) => ({
+    routes: router.routes,
+    prefix: joinPaths(router.prefix, prefix),
+    routeIndex: router.routeIndex,
+});
+const group = (router, prefix, callback) => {
+    callback(scopeRouter(router, prefix));
+};
+const resource = (router, path, controller) => {
+    const base = joinPaths(router.prefix, path);
+    const withId = `${base.endsWith('/') ? base.slice(0, -1) : base}/:id`;
+    if (controller.index)
+        registerRoute(router, 'GET', base, controller.index);
+    if (controller.store)
+        registerRoute(router, 'POST', base, controller.store);
+    if (controller.show)
+        registerRoute(router, 'GET', withId, controller.show);
+    if (controller.update) {
+        registerRoute(router, 'PUT', withId, controller.update);
+        registerRoute(router, 'PATCH', withId, controller.update);
+    }
+    if (controller.destroy)
+        registerRoute(router, 'DELETE', withId, controller.destroy);
+};
+const get = (router, path, handler) => {
+    registerRoute(router, 'GET', joinPaths(router.prefix, path), handler);
+};
+const post = (router, path, handler) => {
+    registerRoute(router, 'POST', joinPaths(router.prefix, path), handler);
+};
+const put = (router, path, handler) => {
+    registerRoute(router, 'PUT', joinPaths(router.prefix, path), handler);
+};
+const patch = (router, path, handler) => {
+    registerRoute(router, 'PATCH', joinPaths(router.prefix, path), handler);
+};
+const del = (router, path, handler) => {
+    registerRoute(router, 'DELETE', joinPaths(router.prefix, path), handler);
+};
+const any = (router, path, handler) => {
+    const fullPath = joinPaths(router.prefix, path);
+    ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'].forEach((method) => {
+        registerRoute(router, method, fullPath, handler);
+    });
+};
+const match = (router, method, path) => matchRoute(router, method, path);
+const getRoutes = (router) => router.routes;
+/**
+ * Router - Sealed namespace for HTTP routing
+ * All operations grouped in frozen namespace to prevent mutation
+ */
+export const Router = Object.freeze({
+    createRouter,
+    scopeRouter,
+    group,
+    resource,
+    get,
+    post,
+    put,
+    patch,
+    del,
+    any,
+    match,
+    getRoutes,
+});
+export default Router;

package/src/runtime/PluginManager.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Plugin Manager
+ * Handles installation and removal of framework plugins.
+ */
+import { PluginDefinition } from './PluginRegistry';
+export declare const PluginManager: Readonly<{
+    /**
+     * List all available plugins
+     */
+    list(): Record<string, PluginDefinition>;
+    /**
+     * Resolve a plugin ID from an alias or full ID
+     */
+    resolveId(idOrAlias: string): string | null;
+    /**
+     * Check if a plugin is currently installed
+     */
+    isInstalled(pluginId: string): Promise<boolean>;
+    /**
+     * Install a plugin
+     */
+    install(pluginId: string): Promise<void>;
+    /**
+     * Uninstall a plugin
+     * Note: This does NOT uninstall dependencies to avoid breaking other things,
+     * but it does revert the code to the "stub" state if possible, or delete the file.
+     */
+    uninstall(pluginId: string): Promise<void>;
+}>;
+//# sourceMappingURL=PluginManager.d.ts.map

package/src/runtime/PluginManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginManager.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginManager.ts"],"names":[],"mappings":"AAEA;;;GAGG;AAQH,OAAO,EAAE,gBAAgB,EAAkB,MAAM,yBAAyB,CAAC;AAwG3E,eAAO,MAAM,aAAa;IACxB;;OAEG;YACK,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAIxC;;OAEG;yBACkB,MAAM,GAAG,MAAM,GAAG,IAAI;IAW3C;;OAEG;0BACyB,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoCrD;;OAEG;sBACqB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkB9C;;;;OAIG;wBACuB,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;EA2ChD,CAAC"}

package/src/runtime/PluginManager.js

@@ -0,0 +1,197 @@
+/* eslint-disable @typescript-eslint/require-await */
+/* eslint-disable no-await-in-loop */
+/**
+ * Plugin Manager
+ * Handles installation and removal of framework plugins.
+ */
+import { Logger } from '../config/logger';
+import { ErrorFactory } from '../exceptions/ZintrustError';
+import { execSync } from '../node-singletons/child-process';
+import { fsPromises as fs } from '../node-singletons/fs';
+import * as path from '../node-singletons/path';
+import { fileURLToPath } from '../node-singletons/url';
+import { PluginRegistry } from './PluginRegistry';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, '../../');
+function isStringRecord(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    for (const v of Object.values(value)) {
+        if (typeof v !== 'string')
+            return false;
+    }
+    return true;
+}
+function parsePackageJsonDeps(text) {
+    const parsed = JSON.parse(text);
+    if (typeof parsed !== 'object' || parsed === null)
+        return {};
+    const obj = parsed;
+    const dependencies = isStringRecord(obj['dependencies']) ? obj['dependencies'] : undefined;
+    const devDependencies = isStringRecord(obj['devDependencies'])
+        ? obj['devDependencies']
+        : undefined;
+    return { dependencies, devDependencies };
+}
+function getPluginOrThrow(pluginId) {
+    const resolvedId = PluginManager.resolveId(pluginId);
+    if (resolvedId === null) {
+        throw ErrorFactory.createNotFoundError(`Plugin ${pluginId} not found`, { pluginId });
+    }
+    return { resolvedId, plugin: PluginRegistry[resolvedId] };
+}
+function npmInstall(packages, options) {
+    if (packages.length === 0)
+        return;
+    Logger.info(`Installing ${options.label}: ${packages.join(', ')}...`);
+    const devFlag = options.dev ? '-D ' : '';
+    try {
+        const cmd = `npm install ${devFlag}${packages.join(' ')}`; // NOSONAR
+        execSync(cmd, {
+            stdio: 'inherit',
+            cwd: PROJECT_ROOT,
+        });
+    }
+    catch (error) {
+        ErrorFactory.createCliError(`Failed to install ${options.label}`, { error });
+        throw error;
+    }
+}
+async function copyPluginTemplates(plugin) {
+    for (const template of plugin.templates) {
+        const sourcePath = path.join(PROJECT_ROOT, 'src/templates', template.source);
+        const destPath = path.join(PROJECT_ROOT, template.destination);
+        Logger.info(`Copying ${template.source} to ${template.destination}...`);
+        try {
+            // Ensure destination directory exists
+            await fs.mkdir(path.dirname(destPath), { recursive: true });
+            // Read and write file
+            const content = await fs.readFile(sourcePath, 'utf-8');
+            await fs.writeFile(destPath, content, 'utf-8');
+        }
+        catch (error) {
+            ErrorFactory.createCliError(`Failed to copy template ${template.source}`, { error });
+            throw error;
+        }
+    }
+}
+function runPostInstall(plugin) {
+    if (!plugin.postInstall)
+        return;
+    if (plugin.postInstall.command !== undefined) {
+        Logger.info(`Running post-install command: ${plugin.postInstall.command}...`);
+        try {
+            execSync(plugin.postInstall.command, {
+                stdio: 'inherit',
+                cwd: PROJECT_ROOT,
+            });
+        }
+        catch (error) {
+            ErrorFactory.createCliError('Post-install command failed', { error });
+        }
+    }
+    if (plugin.postInstall.message !== undefined && plugin.postInstall.message.length > 0) {
+        Logger.info('----------------------------------------');
+        Logger.info(plugin.postInstall.message);
+        Logger.info('----------------------------------------');
+    }
+}
+export const PluginManager = Object.freeze({
+    /**
+     * List all available plugins
+     */
+    list() {
+        return PluginRegistry;
+    },
+    /**
+     * Resolve a plugin ID from an alias or full ID
+     */
+    resolveId(idOrAlias) {
+        if (PluginRegistry[idOrAlias] !== undefined)
+            return idOrAlias;
+        for (const [id, plugin] of Object.entries(PluginRegistry)) {
+            if (plugin.aliases.includes(idOrAlias)) {
+                return id;
+            }
+        }
+        return null;
+    },
+    /**
+     * Check if a plugin is currently installed
+     */
+    async isInstalled(pluginId) {
+        const resolvedId = PluginManager.resolveId(pluginId);
+        if (resolvedId === null) {
+            throw ErrorFactory.createNotFoundError(`Plugin ${pluginId} not found`, { pluginId });
+        }
+        const plugin = PluginRegistry[resolvedId];
+        // Check if the main template file exists in the destination
+        // We assume if the first template exists, the plugin is "installed"
+        if (plugin.templates.length > 0) {
+            const destPath = path.join(PROJECT_ROOT, plugin.templates[0].destination);
+            try {
+                await fs.access(destPath);
+                // Also check if dependencies are in package.json
+                const packageJsonPath = path.join(PROJECT_ROOT, 'package.json');
+                const packageJsonText = await fs.readFile(packageJsonPath, 'utf-8');
+                const packageJson = parsePackageJsonDeps(packageJsonText);
+                const hasDeps = plugin.dependencies.every((dep) => packageJson.dependencies?.[dep] ?? packageJson.devDependencies?.[dep] ?? '');
+                return hasDeps;
+            }
+            catch {
+                ErrorFactory.createCliError(`Plugin ${plugin.name} not installed (missing files or dependencies)`);
+                return false;
+            }
+        }
+        return false;
+    },
+    /**
+     * Install a plugin
+     */
+    async install(pluginId) {
+        const { plugin } = getPluginOrThrow(pluginId);
+        Logger.info(`Installing plugin: ${plugin.name}...`);
+        // 1. Install dependencies
+        npmInstall(plugin.dependencies, { dev: false, label: 'dependencies' });
+        npmInstall(plugin.devDependencies, { dev: true, label: 'dev dependencies' });
+        // 2. Copy templates
+        await copyPluginTemplates(plugin);
+        // 3. Post-Install
+        runPostInstall(plugin);
+        Logger.info(`✓ Plugin ${plugin.name} installed successfully`);
+    },
+    /**
+     * Uninstall a plugin
+     * Note: This does NOT uninstall dependencies to avoid breaking other things,
+     * but it does revert the code to the "stub" state if possible, or delete the file.
+     */
+    async uninstall(pluginId) {
+        const resolvedId = PluginManager.resolveId(pluginId);
+        if (resolvedId === null) {
+            throw ErrorFactory.createNotFoundError(`Plugin ${pluginId} not found`, { pluginId });
+        }
+        const plugin = PluginRegistry[resolvedId];
+        Logger.info(`Uninstalling plugin: ${plugin.name}...`);
+        // Revert templates to stubs
+        // For now, we'll just delete the file if it's an adapter,
+        // BUT wait - we need the stubs to exist for the framework to compile if they are referenced.
+        // However, in the "Template" architecture, the stubs ARE the default state.
+        // So "uninstalling" might mean "restoring the stub".
+        // Since we don't have a "stub repository" easily accessible here without reading from git or a backup,
+        // and the user might have modified the file, "uninstall" is tricky.
+        // Strategy:
+        // 1. Warn the user that this will delete the file.
+        // 2. If it's a core adapter, we should probably restore a basic stub.
+        // For this iteration, we will just warn and delete, assuming the user knows what they are doing.
+        // OR, better: We can have a "stubs" folder in templates too?
+        // Actually, the "stubs" are what is currently in the codebase.
+        // When we "install", we overwrite the stub.
+        // When we "uninstall", we should ideally restore the stub.
+        // Let's check if we have a stub backup. If not, maybe we just leave the file but warn?
+        // Or maybe we don't support "uninstall" fully yet, just "install".
+        Logger.warn('Uninstalling plugins is not fully automated yet. You may need to manually revert file changes.');
+        // We can at least try to remove the dependencies if they are not used elsewhere?
+        // Too risky.
+        Logger.info(`✓ Plugin ${plugin.name} uninstalled (files preserved, please revert manually if needed)`);
+    },
+});

package/src/runtime/PluginRegistry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Plugin Registry
+ * Defines available plugins, their dependencies, and template paths.
+ */
+export interface PluginDefinition {
+    name: string;
+    description: string;
+    type: 'database-adapter' | 'feature';
+    aliases: string[];
+    dependencies: string[];
+    devDependencies: string[];
+    templates: {
+        source: string;
+        destination: string;
+    }[];
+    postInstall?: {
+        message?: string;
+        command?: string;
+    };
+}
+export declare const PluginRegistry: Record<string, PluginDefinition>;
+//# sourceMappingURL=PluginRegistry.d.ts.map

package/src/runtime/PluginRegistry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginRegistry.d.ts","sourceRoot":"","sources":["../../../src/runtime/PluginRegistry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,kBAAkB,GAAG,SAAS,CAAC;IACrC,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,SAAS,EAAE;QACT,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,EAAE,MAAM,CAAC;KACrB,EAAE,CAAC;IACJ,WAAW,CAAC,EAAE;QACZ,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,CAAC;CACH;AAED,eAAO,MAAM,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAwF3D,CAAC"}

package/src/runtime/PluginRegistry.js

@@ -0,0 +1,93 @@
+/**
+ * Plugin Registry
+ * Defines available plugins, their dependencies, and template paths.
+ */
+export const PluginRegistry = {
+    'feature:auth': {
+        name: 'Authentication Feature',
+        description: 'JWT and Bcrypt based authentication helper',
+        type: 'feature',
+        aliases: ['f:auth', 'auth'],
+        dependencies: ['jsonwebtoken', 'bcrypt'],
+        devDependencies: ['@types/jsonwebtoken', '@types/bcrypt'],
+        templates: [
+            {
+                source: 'features/Auth.ts.tpl',
+                destination: 'src/features/Auth.ts',
+            },
+        ],
+        postInstall: {
+            message: 'Authentication installed! Please add JWT_SECRET to your .env file.',
+        },
+    },
+    'feature:queue': {
+        name: 'Queue Feature',
+        description: 'Simple job queue interface (In-Memory default)',
+        type: 'feature',
+        aliases: ['f:queue', 'queue'],
+        dependencies: [],
+        devDependencies: [],
+        templates: [
+            {
+                source: 'features/Queue.ts.tpl',
+                destination: 'src/features/Queue.ts',
+            },
+        ],
+    },
+    'adapter:postgres': {
+        name: 'PostgreSQL Adapter',
+        description: 'Production-ready PostgreSQL database adapter using pg',
+        type: 'database-adapter',
+        aliases: ['a:postgres', 'pg'],
+        dependencies: ['pg'],
+        devDependencies: ['@types/pg'],
+        templates: [
+            {
+                source: 'adapters/PostgreSQLAdapter.ts.tpl',
+                destination: 'src/orm/adapters/PostgreSQLAdapter.ts',
+            },
+        ],
+    },
+    'adapter:mysql': {
+        name: 'MySQL Adapter',
+        description: 'Production-ready MySQL database adapter using mysql2',
+        type: 'database-adapter',
+        aliases: ['a:mysql', 'mysql'],
+        dependencies: ['mysql2'],
+        devDependencies: [],
+        templates: [
+            {
+                source: 'adapters/MySQLAdapter.ts.tpl',
+                destination: 'src/orm/adapters/MySQLAdapter.ts',
+            },
+        ],
+    },
+    'adapter:mssql': {
+        name: 'SQL Server Adapter',
+        description: 'Production-ready SQL Server database adapter using mssql',
+        type: 'database-adapter',
+        aliases: ['a:mssql', 'mssql'],
+        dependencies: ['mssql'],
+        devDependencies: [],
+        templates: [
+            {
+                source: 'adapters/SQLServerAdapter.ts.tpl',
+                destination: 'src/orm/adapters/SQLServerAdapter.ts',
+            },
+        ],
+    },
+    'adapter:sqlite': {
+        name: 'SQLite Adapter',
+        description: 'Production-ready SQLite database adapter using better-sqlite3',
+        type: 'database-adapter',
+        aliases: ['a:sqlite', 'sqlite'],
+        dependencies: ['better-sqlite3'],
+        devDependencies: ['@types/better-sqlite3'],
+        templates: [
+            {
+                source: 'adapters/SQLiteAdapter.ts.tpl',
+                destination: 'src/orm/adapters/SQLiteAdapter.ts',
+            },
+        ],
+    },
+};

package/src/runtime/RuntimeAdapter.d.ts

@@ -0,0 +1,126 @@
+import type { IncomingMessage, ServerResponse } from '../node-singletons/http';
+type Tbody = string | Buffer | null;
+/**
+ * Request body type for handlers
+ */
+export type IRequestBody = Buffer;
+/**
+ * HTTP request/response for serverless and edge platforms
+ */
+export interface PlatformRequest {
+    method: string;
+    path: string;
+    headers: Record<string, string | string[]>;
+    body?: Tbody;
+    query?: Record<string, string | string[]>;
+    remoteAddr?: string;
+}
+export interface PlatformResponse {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body?: Tbody;
+    isBase64Encoded?: boolean;
+}
+/**
+ * RuntimeAdapter interface for platform-agnostic HTTP handling
+ * Allows single codebase deployment to Lambda, Fargate, Cloudflare, Deno
+ */
+export interface RuntimeAdapter {
+    /**
+     * Platform identifier
+     */
+    platform: 'nodejs' | 'lambda' | 'fargate' | 'cloudflare' | 'deno';
+    /**
+     * Handle platform-specific request event
+     * Convert to standard HTTP format, process, and normalize response
+     */
+    handle(event: unknown, context?: unknown): Promise<PlatformResponse>;
+    /**
+     * Convert platform event to standard PlatformRequest
+     */
+    parseRequest(event: unknown): PlatformRequest;
+    /**
+     * Convert Zintrust response to platform-specific format
+     */
+    formatResponse(response: PlatformResponse): unknown;
+    /**
+     * Get platform-specific logger for debugging
+     */
+    getLogger(): {
+        debug(msg: string, data?: unknown): void;
+        info(msg: string, data?: unknown): void;
+        warn(msg: string, data?: unknown): void;
+        error(msg: string, err?: Error): void;
+    };
+    /**
+     * Check if platform supports persistent connections
+     */
+    supportsPersistentConnections(): boolean;
+    /**
+     * Get environment configuration object
+     */
+    getEnvironment(): {
+        nodeEnv: string;
+        runtime: string;
+        dbConnection: string;
+        dbHost?: string;
+        dbPort?: number;
+        [key: string]: unknown;
+    };
+}
+/**
+ * Request handler that processes HTTP requests through Zintrust framework
+ */
+export type ZintrustHandler = (req: IncomingMessage, res: ServerResponse, body: Tbody) => Promise<void>;
+/**
+ * Adapter configuration options
+ */
+export interface AdapterConfig {
+    handler: ZintrustHandler;
+    logger?: {
+        debug(msg: string, data?: unknown): void;
+        info(msg: string, data?: unknown): void;
+        warn(msg: string, data?: unknown): void;
+        error(msg: string, err?: Error): void;
+    };
+    timeout?: number;
+    maxBodySize?: number;
+}
+/**
+ * Response wrapper for normalizing HTTP responses across platforms
+ */
+export interface IHttpResponse {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body: Tbody;
+    isBase64Encoded: boolean;
+    setStatus(code: number): IHttpResponse;
+    setHeader(key: string, value: string | string[]): IHttpResponse;
+    setHeaders(headers: Record<string, string | string[]>): IHttpResponse;
+    setBody(body: Tbody, isBase64?: boolean): IHttpResponse;
+    setJSON(data: unknown): IHttpResponse;
+    toResponse(): PlatformResponse;
+}
+export declare const HttpResponse: Readonly<{
+    create(): IHttpResponse;
+}>;
+/**
+ * Error response helper
+ */
+export declare const ErrorResponse: Readonly<{
+    create(statusCode: number, message: string, details?: unknown): IHttpResponse;
+}>;
+/**
+ * Create mock Node.js request/response objects for platform compatibility
+ */
+export declare function createMockHttpObjects(request: PlatformRequest): {
+    req: Record<string, unknown>;
+    res: Record<string, unknown>;
+    responseData: {
+        statusCode: number;
+        headers: Record<string, string | string[]>;
+        body: Tbody;
+    };
+};
+export {};
+//# sourceMappingURL=RuntimeAdapter.d.ts.map

package/src/runtime/RuntimeAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RuntimeAdapter.d.ts","sourceRoot":"","sources":["../../../src/runtime/RuntimeAdapter.ts"],"names":[],"mappings":"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"}