typed-bridge 2.1.5 → 3.0.1

package/dist/bridge/index.d.ts

@@ -1,8 +1,13 @@
 import { Application, Request, Response } from 'express';
 import { Server } from 'http';
-type Bridge = {
-    [key: string]: (...args: any[]) => Promise<any>;
-};
+import { MCPGetContext } from '../mcp';
+import { Bridge, BridgeEntries, LLMToolFormat } from '../tools';
+interface CreateBridgeOptions {
+    entries?: BridgeEntries;
+    toolsFormat?: LLMToolFormat;
+    mcp?: boolean | string;
+    mcpGetContext?: MCPGetContext;
+}
 type Middleware = {
     pattern: string;
     handler: (req: Request, res: Response) => Promise<{
@@ -12,7 +17,7 @@ type Middleware = {
 };
 export declare const createMiddleware: (pattern: string, handler: Middleware["handler"]) => number;
 export declare const onShutdown: (fn: () => void) => () => void;
-export declare const createBridge: (bridge: Bridge, port: number, path?: string) => {
+export declare const createBridge: (bridge: Bridge, port: number, path?: string, options?: CreateBridgeOptions) => {
     app: Application;
     server: Server;
 };

package/dist/bridge/index.js

@@ -11,13 +11,15 @@ const express_1 = __importDefault(require("express"));
 const path_1 = __importDefault(require("path"));
 const __1 = require("..");
 const helpers_1 = require("../helpers");
+const mcp_1 = require("../mcp");
+const tools_1 = require("../tools");
 const middlewares = [];
 const createMiddleware = (pattern, handler) => middlewares.push({ pattern, handler });
 exports.createMiddleware = createMiddleware;
 let shutdownCallback = () => { };
 const onShutdown = (fn) => (shutdownCallback = fn);
 exports.onShutdown = onShutdown;
-const createBridge = (bridge, port, path = '/bridge') => {
+const createBridge = (bridge, port, path = '/bridge', options) => {
     const app = (0, express_1.default)();
     // cors
     app.use((0, cors_1.default)());
@@ -84,6 +86,32 @@ const createBridge = (bridge, port, path = '/bridge') => {
             timestamp: new Date().toISOString()
         });
     });
+    // LLM tools endpoint
+    if (options?.entries) {
+        const entries = options.entries;
+        const defaultFormat = options.toolsFormat || 'openai';
+        app.get(path_1.default.join(path, 'tools'), (req, res) => {
+            const requestedFormat = req.query.format;
+            // No format provided → use the configured default
+            if (requestedFormat === undefined) {
+                res.json((0, tools_1.toLLMTools)(entries, { format: defaultFormat }));
+                return;
+            }
+            // Reject unknown formats instead of silently returning an empty tool list
+            if (typeof requestedFormat !== 'string' || !(0, tools_1.isLLMToolFormat)(requestedFormat)) {
+                res.status(400).json({
+                    error: `Invalid format: ${String(requestedFormat)}. Expected one of ${tools_1.LLM_TOOL_FORMATS.join(', ')}`
+                });
+                return;
+            }
+            res.json((0, tools_1.toLLMTools)(entries, { format: requestedFormat }));
+        });
+    }
+    // MCP endpoint
+    if (options?.mcp && options?.entries) {
+        const mcpPath = typeof options.mcp === 'string' ? options.mcp : path_1.default.join(path, 'mcp');
+        (0, mcp_1.mountMCP)(app, bridge, options.entries, mcpPath, options.mcpGetContext);
+    }
     app.use(path, bridgeHandler(bridge));
     const server = app.listen(port, () => (0, helpers_1.printStartLogs)(port));
     let shuttingDown = false;
@@ -136,9 +164,9 @@ const bridgeHandler = (bridge) => async (req, res) => {
             console.error(`ARGS | ${id} ::`, JSON.stringify(args, null, 2));
         if (__1.tbConfig.logs.contextOnError)
             console.error(`CONTEXT | ${id} ::`, JSON.stringify(context, null, 2));
-        if (Array.isArray(error.errors)) {
-            const keyPath = error.errors[0].path.join('/');
-            const errorMessage = (keyPath ? keyPath + ': ' : '') + error.errors[0].message;
+        if (Array.isArray(error.issues) && error.issues.length) {
+            const keyPath = error.issues[0].path.join('/');
+            const errorMessage = (keyPath ? keyPath + ': ' : '') + error.issues[0].message;
             return res.status(400).send(errorMessage);
         }
         if (__1.tbConfig.logs.error)

package/dist/config/index.d.ts

@@ -7,6 +7,7 @@ interface config {
         contextOnError: boolean;
     };
     responseDelay: number;
+    maxToolOutputChars: number;
 }
 export declare const config: config;
 export {};

package/dist/config/index.js

@@ -9,5 +9,6 @@ exports.config = {
         argsOnError: true,
         contextOnError: true
     },
-    responseDelay: 0
+    responseDelay: 0,
+    maxToolOutputChars: 0
 };

package/dist/index.d.ts

@@ -1,4 +1,8 @@
 export { Application, default as express, Express, NextFunction, Request, Response, Router } from 'express';
 export { createBridge, createMiddleware, onShutdown } from './bridge';
 export { config as tbConfig } from './config';
+export { mountMCP } from './mcp';
+export type { MCPGetContext } from './mcp';
+export { defineBridge, getMetaTools, handleMetaToolCall, toLLMTools, toolDescribe, toolSearch, toolUse } from './tools';
+export type { Bridge, BridgeEntries, BridgeEntry, LLMToolFormat, ToLLMToolsOptions, ToolCall } from './tools';
 export { z } from 'zod';

package/dist/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.z = exports.tbConfig = exports.onShutdown = exports.createMiddleware = exports.createBridge = exports.Router = exports.express = void 0;
+exports.z = exports.toolUse = exports.toolSearch = exports.toolDescribe = exports.toLLMTools = exports.handleMetaToolCall = exports.getMetaTools = exports.defineBridge = exports.mountMCP = exports.tbConfig = exports.onShutdown = exports.createMiddleware = exports.createBridge = exports.Router = exports.express = void 0;
 var express_1 = require("express");
 Object.defineProperty(exports, "express", { enumerable: true, get: function () { return __importDefault(express_1).default; } });
 Object.defineProperty(exports, "Router", { enumerable: true, get: function () { return express_1.Router; } });
@@ -13,5 +13,15 @@ Object.defineProperty(exports, "createMiddleware", { enumerable: true, get: func
 Object.defineProperty(exports, "onShutdown", { enumerable: true, get: function () { return bridge_1.onShutdown; } });
 var config_1 = require("./config");
 Object.defineProperty(exports, "tbConfig", { enumerable: true, get: function () { return config_1.config; } });
+var mcp_1 = require("./mcp");
+Object.defineProperty(exports, "mountMCP", { enumerable: true, get: function () { return mcp_1.mountMCP; } });
+var tools_1 = require("./tools");
+Object.defineProperty(exports, "defineBridge", { enumerable: true, get: function () { return tools_1.defineBridge; } });
+Object.defineProperty(exports, "getMetaTools", { enumerable: true, get: function () { return tools_1.getMetaTools; } });
+Object.defineProperty(exports, "handleMetaToolCall", { enumerable: true, get: function () { return tools_1.handleMetaToolCall; } });
+Object.defineProperty(exports, "toLLMTools", { enumerable: true, get: function () { return tools_1.toLLMTools; } });
+Object.defineProperty(exports, "toolDescribe", { enumerable: true, get: function () { return tools_1.toolDescribe; } });
+Object.defineProperty(exports, "toolSearch", { enumerable: true, get: function () { return tools_1.toolSearch; } });
+Object.defineProperty(exports, "toolUse", { enumerable: true, get: function () { return tools_1.toolUse; } });
 var zod_1 = require("zod");
 Object.defineProperty(exports, "z", { enumerable: true, get: function () { return zod_1.z; } });

package/dist/mcp/index.d.ts

@@ -0,0 +1,5 @@
+import { IncomingHttpHeaders } from 'node:http';
+import { Application } from 'express';
+import { Bridge, BridgeEntries } from '../tools';
+export type MCPGetContext = (headers: IncomingHttpHeaders) => Record<string, unknown> | Promise<Record<string, unknown>>;
+export declare function mountMCP(app: Application, bridge: Bridge, entries: BridgeEntries, path?: string, getContext?: MCPGetContext): void;

package/dist/mcp/index.js

@@ -0,0 +1,119 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mountMCP = mountMCP;
+const node_crypto_1 = require("node:crypto");
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const tools_1 = require("../tools");
+const SESSION_TTL_MS = 30 * 60 * 1000;
+const SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+const MAX_SESSIONS = 1000;
+function createMCPServer(bridge, entries, headersRef, getContext) {
+    const server = new index_js_1.Server({ name: 'typed-bridge', version: '1.0.0' }, { capabilities: { tools: {} } });
+    // An entry is exposed to MCP unless it explicitly opts out with `mcp: false`
+    const isExposed = (entry) => !!entry && entry.mcp !== false;
+    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+        const tools = Object.entries(entries)
+            .filter(([, entry]) => isExposed(entry))
+            .map(([name, entry]) => ({
+            name,
+            description: entry.description,
+            inputSchema: (0, tools_1.toToolInputSchema)(entry.args)
+        }));
+        return { tools };
+    });
+    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        try {
+            // Block execution of hidden tools, not just their listing
+            if (!isExposed(entries[name]))
+                throw new Error(`Tool not found: ${name}`);
+            const handler = bridge[name];
+            if (!handler)
+                throw new Error(`Tool not found: ${name}`);
+            // Derive per-request context from forwarded headers
+            const context = getContext ? await getContext(headersRef.current) : undefined;
+            const result = await handler(args || {}, context);
+            // Throws if the result exceeds tbConfig.maxToolOutputChars — handled below as isError
+            const text = (0, tools_1.enforceToolOutputLimit)(result);
+            return { content: [{ type: 'text', text }] };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return { content: [{ type: 'text', text: message }], isError: true };
+        }
+    });
+    return server;
+}
+function mountMCP(app, bridge, entries, path = '/mcp', getContext) {
+    const sessions = new Map();
+    // Evict sessions idle for longer than SESSION_TTL_MS
+    const sweepInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [id, session] of sessions) {
+            if (now - session.lastActivity > SESSION_TTL_MS) {
+                session.server.close().catch(() => { });
+                sessions.delete(id);
+            }
+        }
+    }, SWEEP_INTERVAL_MS);
+    sweepInterval.unref();
+    const handler = async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        let transport;
+        if (sessionId && sessions.has(sessionId)) {
+            const session = sessions.get(sessionId);
+            session.lastActivity = Date.now();
+            session.headersRef.current = req.headers;
+            transport = session.transport;
+        }
+        else if (!sessionId && req.method === 'POST') {
+            const headersRef = { current: req.headers };
+            const server = createMCPServer(bridge, entries, headersRef, getContext);
+            transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                sessionIdGenerator: () => (0, node_crypto_1.randomUUID)(),
+                onsessioninitialized: (id) => {
+                    // Bound memory: evict the least-recently-active session when at capacity
+                    if (sessions.size >= MAX_SESSIONS)
+                        evictOldestSession(sessions);
+                    sessions.set(id, { transport, server, lastActivity: Date.now(), headersRef });
+                    transport.onclose = () => sessions.delete(id);
+                }
+            });
+            await server.connect(transport);
+        }
+        else {
+            res.status(400).json({ error: 'Invalid or missing session' });
+            return;
+        }
+        await transport.handleRequest(req, res, req.body);
+    };
+    app.post(path, handler);
+    app.get(path, handler);
+    app.delete(path, async (req, res) => {
+        const sessionId = req.headers['mcp-session-id'];
+        if (!sessionId || !sessions.has(sessionId)) {
+            res.status(400).json({ error: 'Invalid or missing session' });
+            return;
+        }
+        const session = sessions.get(sessionId);
+        sessions.delete(sessionId);
+        await session.server.close().catch(() => { });
+        res.status(200).end();
+    });
+}
+function evictOldestSession(sessions) {
+    let oldestId;
+    let oldestSession;
+    for (const [id, session] of sessions) {
+        if (!oldestSession || session.lastActivity < oldestSession.lastActivity) {
+            oldestId = id;
+            oldestSession = session;
+        }
+    }
+    if (oldestId && oldestSession) {
+        oldestSession.server.close().catch(() => { });
+        sessions.delete(oldestId);
+    }
+}

package/dist/scripts/buildTypeBridge.js

@@ -4,12 +4,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = build;
+const path_1 = __importDefault(require("path"));
 const rollup_1 = require("rollup");
 const rollup_plugin_dts_1 = __importDefault(require("rollup-plugin-dts"));
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Consumers import `z` from `typed-bridge`, which re-exports typed-bridge's own
+ * nested zod (`typed-bridge/node_modules/zod`). When the consumer's bridge has no
+ * type annotation, declaration emit must name that nested zod and fails with
+ * TS2742 ("cannot be named without a reference to ... This is likely not portable").
+ *
+ * Aliasing a bare `zod` specifier to typed-bridge's zod makes the inferred types
+ * portably nameable, so emit succeeds. The cleaner strips every zod reference
+ * afterwards, so this only needs to satisfy the compiler, not the final output.
+ */
+function resolveTypeRoots(src) {
+    // Preserve the consumer's own path aliases (e.g. `@/*`) so handler files resolve
+    const configPath = typescript_1.default.findConfigFile(path_1.default.dirname(path_1.default.resolve(src)), typescript_1.default.sys.fileExists, 'tsconfig.json');
+    let baseUrl = process.cwd();
+    let paths = {};
+    if (configPath) {
+        const read = typescript_1.default.readConfigFile(configPath, typescript_1.default.sys.readFile);
+        const parsed = typescript_1.default.parseJsonConfigFileContent(read.config, typescript_1.default.sys, path_1.default.dirname(configPath));
+        baseUrl = parsed.options.baseUrl || path_1.default.dirname(configPath);
+        paths = { ...(parsed.options.paths || {}) };
+    }
+    try {
+        const zodDir = path_1.default.dirname(require.resolve('zod/package.json'));
+        paths = { ...paths, zod: [zodDir], 'zod/*': [path_1.default.join(zodDir, '*')] };
+    }
+    catch {
+        // zod not resolvable — fall back to default behaviour
+    }
+    return { baseUrl, paths };
+}
 async function build(src = '', dest = '') {
+    const { baseUrl, paths } = resolveTypeRoots(src);
     const bundle = await (0, rollup_1.rollup)({
         input: src,
-        plugins: [(0, rollup_plugin_dts_1.default)({ respectExternal: false })],
+        plugins: [(0, rollup_plugin_dts_1.default)({ respectExternal: false, compilerOptions: { baseUrl, paths } })],
         onwarn(warning, warn) {
             if (warning.code === 'UNRESOLVED_IMPORT')
                 return;

package/dist/scripts/typedBridgeCleaner.js

@@ -9,31 +9,28 @@ const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 // Snippet to inject at the end
 const proxySnippet = () => `
-type typedBridgeConfig = {
+type TypedBridgeConfig = {
     host: string
-    headers: { [key: string]: string }
-    onResponse: (res: Response) => void
+    headers: Record<string, string>
+    onResponse: (response: Response) => void
 }
 
-export const typedBridgeConfig: typedBridgeConfig = {
+export const typedBridgeConfig: TypedBridgeConfig = {
     host: '',
     headers: { 'Content-Type': 'application/json' },
-    onResponse: (res: Response) => {}
+    onResponse: () => {}
 }
 
 export const typedBridge = new Proxy(
     {},
     {
         get(_, methodName: string) {
-            return async (args: any) => {
+            return async (args: unknown) => {
                 const response = await fetch(
                     typedBridgeConfig.host + (typedBridgeConfig.host.endsWith('/') ? '' : '/') + methodName,
                     {
                         method: 'POST',
-                        headers: {
-                            'Content-Type': 'application/json',
-                            ...typedBridgeConfig.headers
-                        },
+                        headers: typedBridgeConfig.headers,
                         body: JSON.stringify(args)
                     }
                 )
@@ -53,7 +50,7 @@ export const typedBridge = new Proxy(
             }
         }
     }
-) as typeof _default
+) as TypedBridge
 
 export default typedBridge
 `;
@@ -72,7 +69,27 @@ const resolveZodTypesTransformer = context => {
             ZodVoid: typescript_1.default.SyntaxKind.VoidKeyword,
             ZodAny: typescript_1.default.SyntaxKind.AnyKeyword,
             ZodUnknown: typescript_1.default.SyntaxKind.UnknownKeyword,
-            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword
+            ZodNever: typescript_1.default.SyntaxKind.NeverKeyword,
+            // Zod 4 branded string types
+            ZodEmail: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodURL: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodUUID: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodEmoji: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodNanoID: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodCUID: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodCUID2: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodULID: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodIPv4: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodIPv6: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodCIDRv4: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodCIDRv6: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodBase64: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodBase64URL: typescript_1.default.SyntaxKind.StringKeyword,
+            ZodJWT: typescript_1.default.SyntaxKind.StringKeyword,
+            // Zod 4 branded number types
+            ZodInt: typescript_1.default.SyntaxKind.NumberKeyword,
+            ZodFloat32: typescript_1.default.SyntaxKind.NumberKeyword,
+            ZodFloat64: typescript_1.default.SyntaxKind.NumberKeyword
         };
         function getZodRef(node) {
             if (typescript_1.default.isTypeReferenceNode(node) &&
@@ -206,31 +223,230 @@ const removeSecondParamTransformer = context => {
 };
 /**
  * Transformer #3:
- * Remove "export { _default as default }" if it exists.
+ * Make any parameter typed as `undefined` optional so callers can omit it.
+ * e.g. `(_args: undefined) => Promise<...>` → `(_args?: undefined) => Promise<...>`
  */
-const removeDefaultExportTransformer = context => {
+const optionalUndefinedParamTransformer = context => {
     return sourceFile => {
         function visitor(node) {
-            // Look for `export { _default as default }` and drop it
-            if (typescript_1.default.isExportDeclaration(node) && node.exportClause && typescript_1.default.isNamedExports(node.exportClause)) {
-                const [el] = node.exportClause.elements;
-                if (node.exportClause.elements.length === 1 &&
-                    el.propertyName?.text === '_default' &&
-                    el.name.text === 'default') {
-                    return undefined;
-                }
+            if (typescript_1.default.isFunctionTypeNode(node)) {
+                const params = node.parameters.map(param => {
+                    if (param.type &&
+                        typescript_1.default.isToken(param.type) &&
+                        param.type.kind === typescript_1.default.SyntaxKind.UndefinedKeyword &&
+                        !param.questionToken) {
+                        return typescript_1.default.factory.updateParameterDeclaration(param, param.modifiers, param.dotDotDotToken, param.name, typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), param.type, param.initializer);
+                    }
+                    return param;
+                });
+                return typescript_1.default.factory.updateFunctionTypeNode(node, node.typeParameters, typescript_1.default.factory.createNodeArray(params), node.type);
             }
             return typescript_1.default.visitEachChild(node, visitor, context);
         }
+        return typescript_1.default.visitEachChild(sourceFile, visitor, context);
+    };
+};
+/**
+ * Transformer #4:
+ * Resolve ExtractHandlers<T> in the _default declaration by unwrapping
+ * { handler: fn, ... } entries to just the function type.
+ * Also removes helper type definitions and the entries declaration that
+ * leak from defineBridge() usage.
+ */
+const unwrapBridgeEntryTransformer = _context => {
+    return sourceFile => {
+        const helperTypes = new Set(['Bridge', 'BridgeEntry', 'BridgeEntries', 'ExtractHandlers']);
+        // Detect the variable bound to the default export. rollup-plugin-dts names an
+        // anonymous `export default defineBridge(...)` as `_default`, but keeps the
+        // user's identifier (e.g. `bridge`) when they do `const bridge = ...; export default bridge`.
+        let defaultName;
+        for (const stmt of sourceFile.statements) {
+            if (typescript_1.default.isExportAssignment(stmt) && !stmt.isExportEquals && typescript_1.default.isIdentifier(stmt.expression)) {
+                defaultName = stmt.expression.text;
+            }
+            if (typescript_1.default.isExportDeclaration(stmt) && stmt.exportClause && typescript_1.default.isNamedExports(stmt.exportClause)) {
+                for (const el of stmt.exportClause.elements) {
+                    if (el.name.text === 'default')
+                        defaultName = (el.propertyName ?? el.name).text;
+                }
+            }
+        }
+        function resolveHandlers(typeLiteral) {
+            const members = typeLiteral.members.map(member => {
+                if (!typescript_1.default.isPropertySignature(member) || !member.type)
+                    return member;
+                if (typescript_1.default.isTypeLiteralNode(member.type)) {
+                    const handlerProp = member.type.members.find(m => typescript_1.default.isPropertySignature(m) &&
+                        typescript_1.default.isIdentifier(m.name) &&
+                        m.name.text === 'handler' &&
+                        m.type &&
+                        typescript_1.default.isFunctionTypeNode(m.type));
+                    if (handlerProp && typescript_1.default.isPropertySignature(handlerProp) && handlerProp.type) {
+                        return typescript_1.default.factory.updatePropertySignature(member, member.modifiers, member.name, member.questionToken, handlerProp.type);
+                    }
+                }
+                return member;
+            });
+            return typescript_1.default.factory.createTypeLiteralNode(members);
+        }
         const updatedStatements = [];
         for (const stmt of sourceFile.statements) {
-            const newStmt = typescript_1.default.visitNode(stmt, visitor);
-            if (newStmt)
-                updatedStatements.push(newStmt);
+            // Remove helper type aliases
+            if (typescript_1.default.isTypeAliasDeclaration(stmt) && helperTypes.has(stmt.name.text))
+                continue;
+            // Remove entries declaration
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                const decl = stmt.declarationList.declarations[0];
+                if (decl && typescript_1.default.isIdentifier(decl.name) && decl.name.text === 'entries')
+                    continue;
+            }
+            // Convert the default-export variable to the TypedBridge type alias
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                const decl = stmt.declarationList.declarations[0];
+                if (decl && typescript_1.default.isIdentifier(decl.name) && decl.name.text === defaultName && decl.type) {
+                    let resolvedType;
+                    // `ExtractHandlers` may be a bare identifier (inlined, same package) or a
+                    // namespace-qualified reference (e.g. `typed_bridge_dist_tools.ExtractHandlers`)
+                    // when typed-bridge is an external dependency in a consumer project.
+                    const refName = typescript_1.default.isTypeReferenceNode(decl.type) &&
+                        (typescript_1.default.isIdentifier(decl.type.typeName)
+                            ? decl.type.typeName.text
+                            : decl.type.typeName.right.text);
+                    if (typescript_1.default.isTypeReferenceNode(decl.type) &&
+                        refName === 'ExtractHandlers' &&
+                        decl.type.typeArguments?.length === 1 &&
+                        typescript_1.default.isTypeLiteralNode(decl.type.typeArguments[0])) {
+                        resolvedType = resolveHandlers(decl.type.typeArguments[0]);
+                    }
+                    else {
+                        resolvedType = decl.type;
+                    }
+                    updatedStatements.push(typescript_1.default.factory.createTypeAliasDeclaration(undefined, 'TypedBridge', undefined, resolvedType));
+                    continue;
+                }
+            }
+            // Strip entries from named exports
+            if (typescript_1.default.isExportDeclaration(stmt) && stmt.exportClause && typescript_1.default.isNamedExports(stmt.exportClause)) {
+                const filtered = stmt.exportClause.elements.filter(el => el.name.text !== 'entries' && el.propertyName?.text !== 'entries');
+                if (filtered.length === 0)
+                    continue;
+                if (filtered.length !== stmt.exportClause.elements.length) {
+                    updatedStatements.push(typescript_1.default.factory.updateExportDeclaration(stmt, stmt.modifiers, stmt.isTypeOnly, typescript_1.default.factory.updateNamedExports(stmt.exportClause, filtered), stmt.moduleSpecifier, stmt.attributes));
+                    continue;
+                }
+            }
+            updatedStatements.push(stmt);
         }
         return typescript_1.default.factory.updateSourceFile(sourceFile, typescript_1.default.factory.createNodeArray(updatedStatements));
     };
 };
+/**
+ * Transformer #5:
+ * Remove the rollup default export (`export { X as default }` for any X, or
+ * `export default X`). The proxy snippet provides its own default export.
+ */
+const removeDefaultExportTransformer = _context => {
+    return sourceFile => {
+        const updatedStatements = [];
+        for (const stmt of sourceFile.statements) {
+            // Drop `export default X` / `export = X`
+            if (typescript_1.default.isExportAssignment(stmt))
+                continue;
+            // Filter `... as default` specifiers out of named exports
+            if (typescript_1.default.isExportDeclaration(stmt) && stmt.exportClause && typescript_1.default.isNamedExports(stmt.exportClause)) {
+                const filtered = stmt.exportClause.elements.filter(el => el.name.text !== 'default');
+                if (filtered.length === 0)
+                    continue;
+                if (filtered.length !== stmt.exportClause.elements.length) {
+                    updatedStatements.push(typescript_1.default.factory.updateExportDeclaration(stmt, stmt.modifiers, stmt.isTypeOnly, typescript_1.default.factory.updateNamedExports(stmt.exportClause, filtered), stmt.moduleSpecifier, stmt.attributes));
+                    continue;
+                }
+            }
+            updatedStatements.push(stmt);
+        }
+        return typescript_1.default.factory.updateSourceFile(sourceFile, typescript_1.default.factory.createNodeArray(updatedStatements));
+    };
+};
+/**
+ * Transformer #6:
+ * Drop every top-level statement that is not reachable from the `TypedBridge`
+ * alias. When typed-bridge is an external dependency, rollup leaves behind stray
+ * imports (e.g. `import * as ... from 'typed-bridge/dist/tools'`) and inlined
+ * context types (e.g. `adminContext`) that the resolved client no longer needs.
+ */
+const pruneUnreachableTransformer = _context => {
+    return sourceFile => {
+        const statements = sourceFile.statements;
+        const typedBridge = statements.find((s) => typescript_1.default.isTypeAliasDeclaration(s) && s.name.text === 'TypedBridge');
+        if (!typedBridge)
+            return sourceFile;
+        const namesOf = (stmt) => {
+            if (typescript_1.default.isTypeAliasDeclaration(stmt) ||
+                typescript_1.default.isInterfaceDeclaration(stmt) ||
+                typescript_1.default.isClassDeclaration(stmt) ||
+                typescript_1.default.isEnumDeclaration(stmt) ||
+                typescript_1.default.isFunctionDeclaration(stmt)) {
+                return stmt.name ? [stmt.name.text] : [];
+            }
+            if (typescript_1.default.isVariableStatement(stmt)) {
+                return stmt.declarationList.declarations.flatMap(d => (typescript_1.default.isIdentifier(d.name) ? [d.name.text] : []));
+            }
+            if (typescript_1.default.isImportDeclaration(stmt) && stmt.importClause) {
+                const names = [];
+                const clause = stmt.importClause;
+                if (clause.name)
+                    names.push(clause.name.text);
+                if (clause.namedBindings) {
+                    if (typescript_1.default.isNamespaceImport(clause.namedBindings))
+                        names.push(clause.namedBindings.name.text);
+                    else
+                        for (const el of clause.namedBindings.elements)
+                            names.push(el.name.text);
+                }
+                return names;
+            }
+            return [];
+        };
+        const declarers = new Map();
+        for (const stmt of statements)
+            for (const n of namesOf(stmt))
+                if (!declarers.has(n))
+                    declarers.set(n, stmt);
+        const refsOf = (node) => {
+            const acc = new Set();
+            const visit = (n) => {
+                if (typescript_1.default.isTypeReferenceNode(n)) {
+                    let tn = n.typeName;
+                    while (typescript_1.default.isQualifiedName(tn))
+                        tn = tn.left;
+                    acc.add(tn.text);
+                }
+                if (typescript_1.default.isTypeQueryNode(n)) {
+                    let en = n.exprName;
+                    while (typescript_1.default.isQualifiedName(en))
+                        en = en.left;
+                    acc.add(en.text);
+                }
+                typescript_1.default.forEachChild(n, visit);
+            };
+            visit(node);
+            return acc;
+        };
+        const keep = new Set([typedBridge]);
+        const queue = [typedBridge];
+        while (queue.length) {
+            const cur = queue.shift();
+            for (const name of refsOf(cur)) {
+                const d = declarers.get(name);
+                if (d && !keep.has(d)) {
+                    keep.add(d);
+                    queue.push(d);
+                }
+            }
+        }
+        return typescript_1.default.factory.updateSourceFile(sourceFile, typescript_1.default.factory.createNodeArray(statements.filter(s => keep.has(s))));
+    };
+};
 /**
  * Main cleaner function.
  *  1. Ensures top comment is present.
@@ -243,14 +459,17 @@ function cleanTsFile(src) {
     const sourceFile = typescript_1.default.createSourceFile(path_1.default.basename(src), sourceCode, typescript_1.default.ScriptTarget.Latest, true, typescript_1.default.ScriptKind.TS);
     // Run the transformers
     const result = typescript_1.default.transform(sourceFile, [
+        unwrapBridgeEntryTransformer,
         resolveZodTypesTransformer,
         removeSecondParamTransformer,
-        removeDefaultExportTransformer
+        optionalUndefinedParamTransformer,
+        removeDefaultExportTransformer,
+        pruneUnreachableTransformer
     ]);
     // Print final code
-    const eslintDisable = `/* eslint-disable */`;
+    const header = `/* This file is auto-generated by typed-bridge. Do not edit. */`;
     const printer = typescript_1.default.createPrinter();
-    const transformedCode = eslintDisable + '\n' + printer.printFile(result.transformed[0]).concat(proxySnippet());
+    const transformedCode = header + '\n' + printer.printFile(result.transformed[0]).concat(proxySnippet());
     // Write back to the same file
     fs_1.default.writeFileSync(src, transformedCode, 'utf-8');
 }