@arcblock/did-connect-js 1.29.12 → 1.29.14

package/esm/adapters/detect.d.mts

@@ -0,0 +1,11 @@
+//#region src/adapters/detect.d.ts
+/**
+ * Detect whether an app object is Express or Hono.
+ *
+ * Express: has set(), engine(), and lazyrouter() or _router
+ * Hono: has fetch() method + basePath property, no Express set/engine
+ */
+declare function isExpressApp(app: any): boolean;
+declare function isHonoApp(app: any): boolean;
+//#endregion
+export { isExpressApp, isHonoApp };

package/esm/adapters/detect.mjs

@@ -0,0 +1,16 @@
+//#region src/adapters/detect.ts
+/**
+* Detect whether an app object is Express or Hono.
+*
+* Express: has set(), engine(), and lazyrouter() or _router
+* Hono: has fetch() method + basePath property, no Express set/engine
+*/
+function isExpressApp(app) {
+	return typeof app?.set === "function" && typeof app?.engine === "function";
+}
+function isHonoApp(app) {
+	return typeof app?.fetch === "function" && !isExpressApp(app);
+}
+
+//#endregion
+export { isExpressApp, isHonoApp };

package/esm/adapters/express.d.mts

@@ -0,0 +1,48 @@
+import { ConnectRequest, ConnectResponse, NextFunction } from "../types.mjs";
+
+//#region src/adapters/express.d.ts
+interface ExpressLikeApp {
+  use(path: string, ...handlers: any[]): void;
+  get(path: string, ...handlers: any[]): void;
+  post(path: string, ...handlers: any[]): void;
+}
+interface HandlerFunctions {
+  generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  ensureContext: (req: ConnectRequest, res: ConnectResponse, next: NextFunction) => Promise<void>;
+  ensureSignedJson: (req: ConnectRequest, res: ConnectResponse, next: NextFunction) => void;
+}
+interface AttachExpressOptions {
+  app: ExpressLikeApp;
+  prefix: string;
+  action: string;
+  handlers: HandlerFunctions;
+}
+/**
+ * Register DID Connect routes on an Express-compatible app.
+ *
+ * Routes registered:
+ * - GET/POST `{prefix}/{action}/token` — generate session
+ * - GET `{prefix}/{action}/status` — check session status
+ * - GET `{prefix}/{action}/timeout` — expire session
+ * - GET `{prefix}/{action}/auth` — wallet fetches auth request
+ * - POST `{prefix}/{action}/auth` — wallet submits auth response
+ * - GET `{prefix}/{action}/auth/submit` — web wallet submit
+ */
+declare function attachExpress({
+  app,
+  prefix,
+  action,
+  handlers
+}: AttachExpressOptions): {
+  generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+};
+//#endregion
+export { AttachExpressOptions, ExpressLikeApp, HandlerFunctions, attachExpress };

package/esm/adapters/express.mjs

@@ -0,0 +1,39 @@
+import cors from "cors";
+
+//#region src/adapters/express.ts
+/**
+* Register DID Connect routes on an Express-compatible app.
+*
+* Routes registered:
+* - GET/POST `{prefix}/{action}/token` — generate session
+* - GET `{prefix}/{action}/status` — check session status
+* - GET `{prefix}/{action}/timeout` — expire session
+* - GET `{prefix}/{action}/auth` — wallet fetches auth request
+* - POST `{prefix}/{action}/auth` — wallet submits auth response
+* - GET `{prefix}/{action}/auth/submit` — web wallet submit
+*/
+function attachExpress({ app, prefix, action, handlers }) {
+	const pathname = `${prefix}/${action}/auth`;
+	const { generateSession, checkSession, expireSession, onAuthRequest, onAuthResponse, ensureContext, ensureSignedJson } = handlers;
+	app.use(`${prefix}/${action}`, cors({
+		origin: "*",
+		optionsSuccessStatus: 204
+	}));
+	app.get(`${prefix}/${action}/token`, generateSession);
+	app.post(`${prefix}/${action}/token`, generateSession);
+	app.get(`${prefix}/${action}/status`, ensureContext, checkSession);
+	app.get(`${prefix}/${action}/timeout`, ensureContext, expireSession);
+	app.get(pathname, ensureContext, ensureSignedJson, onAuthRequest);
+	app.post(pathname, ensureContext, ensureSignedJson, onAuthResponse);
+	app.get(`${pathname}/submit`, ensureContext, ensureSignedJson, onAuthResponse);
+	return {
+		generateSession,
+		expireSession,
+		checkSession,
+		onAuthRequest,
+		onAuthResponse
+	};
+}
+
+//#endregion
+export { attachExpress };

package/esm/adapters/hono.d.mts

@@ -0,0 +1,57 @@
+import { ConnectRequest, ConnectResponse } from "../types.mjs";
+import { HandlerFunctions } from "./express.mjs";
+
+//#region src/adapters/hono.d.ts
+interface HonoLikeApp {
+  get(path: string, handler: (c: any) => any): void;
+  post(path: string, handler: (c: any) => any): void;
+  use(path: string, handler: any): void;
+}
+interface AttachHonoOptions {
+  app: HonoLikeApp;
+  prefix: string;
+  action: string;
+  handlers: HandlerFunctions;
+}
+/**
+ * Create a ConnectRequest from a Hono-like Context.
+ *
+ * @param c - Hono Context object
+ * @param bodyCache - Pre-parsed request body (since c.req.json() is async)
+ */
+declare function createHonoRequest(c: any, bodyCache?: any): ConnectRequest;
+/**
+ * Create a ConnectResponse that buffers the handler's response.
+ * The Hono route wrapper reads the buffer via _getResult() to return c.json().
+ */
+declare function createHonoResponse(): ConnectResponse & {
+  _getResult(): {
+    statusCode: number;
+    body: any;
+  } | null;
+};
+/**
+ * Register DID Connect routes on a Hono-compatible app.
+ *
+ * Routes registered are the same as attachExpress:
+ * - GET/POST `{prefix}/{action}/token`
+ * - GET `{prefix}/{action}/status`
+ * - GET `{prefix}/{action}/timeout`
+ * - GET `{prefix}/{action}/auth`
+ * - POST `{prefix}/{action}/auth`
+ * - GET `{prefix}/{action}/auth/submit`
+ */
+declare function attachHono({
+  app,
+  prefix,
+  action,
+  handlers
+}: AttachHonoOptions): {
+  generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+};
+//#endregion
+export { AttachHonoOptions, HonoLikeApp, attachHono, createHonoRequest, createHonoResponse };

package/esm/adapters/hono.mjs

@@ -0,0 +1,164 @@
+//#region src/adapters/hono.ts
+/**
+* Parse a raw Cookie header string into a key-value map.
+*/
+function parseCookieHeader(header) {
+	const cookies = {};
+	if (!header) return cookies;
+	for (const pair of header.split(";")) {
+		const idx = pair.indexOf("=");
+		if (idx > 0) {
+			const key = pair.slice(0, idx).trim();
+			const val = pair.slice(idx + 1).trim();
+			cookies[key] = decodeURIComponent(val);
+		}
+	}
+	return cookies;
+}
+/**
+* Simple Accept-Language negotiation matching Express's req.acceptsLanguages().
+* Only needs to handle the two languages used by DID Connect: 'en-US' and 'zh-CN'.
+*/
+function negotiateLanguage(acceptHeader, ...langs) {
+	if (!acceptHeader || langs.length === 0) return langs[0] || false;
+	const lower = acceptHeader.toLowerCase();
+	for (const lang of langs) {
+		const prefix = lang.toLowerCase().split("-")[0];
+		if (lower.includes(lang.toLowerCase()) || lower.includes(prefix)) return lang;
+	}
+	return langs[0] || false;
+}
+/**
+* Create a ConnectRequest from a Hono-like Context.
+*
+* @param c - Hono Context object
+* @param bodyCache - Pre-parsed request body (since c.req.json() is async)
+*/
+function createHonoRequest(c, bodyCache = {}) {
+	const url = new URL(c.req.url);
+	const rawHeaders = {};
+	if (c.req.raw?.headers) c.req.raw.headers.forEach((value, key) => {
+		rawHeaders[key.toLowerCase()] = value;
+	});
+	return {
+		body: bodyCache,
+		query: Object.fromEntries(url.searchParams.entries()),
+		params: typeof c.req.param === "function" ? c.req.param() : {},
+		headers: rawHeaders,
+		cookies: parseCookieHeader(rawHeaders.cookie || ""),
+		protocol: url.protocol.replace(":", ""),
+		originalUrl: url.pathname + url.search,
+		get(name) {
+			return rawHeaders[name.toLowerCase()];
+		},
+		acceptsLanguages(...langs) {
+			return negotiateLanguage(rawHeaders["accept-language"] || "", ...langs);
+		},
+		raw: c
+	};
+}
+/**
+* Create a ConnectResponse that buffers the handler's response.
+* The Hono route wrapper reads the buffer via _getResult() to return c.json().
+*/
+function createHonoResponse() {
+	let result = null;
+	return {
+		jsonp(data) {
+			result = {
+				statusCode: 200,
+				body: data
+			};
+		},
+		json(data) {
+			result = {
+				statusCode: 200,
+				body: data
+			};
+		},
+		status(code) {
+			return { json(data) {
+				result = {
+					statusCode: code,
+					body: data
+				};
+			} };
+		},
+		_getResult() {
+			return result;
+		}
+	};
+}
+/**
+* Wrap a middleware chain + handler into a single Hono route handler.
+* Runs middlewares sequentially with manual next() control,
+* then runs the handler, then returns the buffered response.
+*/
+function wrapHandler(middlewares, handler) {
+	return async (c) => {
+		let body = {};
+		try {
+			const text = await c.req.text();
+			if (text) {
+				const contentType = c.req.header("content-type") || "";
+				if (contentType.includes("json")) body = JSON.parse(text);
+				else if (contentType.includes("urlencoded")) body = Object.fromEntries(new URLSearchParams(text).entries());
+			}
+		} catch {}
+		const req = createHonoRequest(c, body);
+		const res = createHonoResponse();
+		for (const mw of middlewares) {
+			let nextCalled = false;
+			await mw(req, res, () => {
+				nextCalled = true;
+			});
+			if (!nextCalled) {
+				const r$1 = res._getResult();
+				if (r$1) return c.json(r$1.body, r$1.statusCode);
+				return c.json({ error: "Unknown error" }, 500);
+			}
+		}
+		await handler(req, res);
+		const r = res._getResult();
+		return c.json(r?.body ?? {}, r?.statusCode ?? 200);
+	};
+}
+/**
+* Register DID Connect routes on a Hono-compatible app.
+*
+* Routes registered are the same as attachExpress:
+* - GET/POST `{prefix}/{action}/token`
+* - GET `{prefix}/{action}/status`
+* - GET `{prefix}/{action}/timeout`
+* - GET `{prefix}/{action}/auth`
+* - POST `{prefix}/{action}/auth`
+* - GET `{prefix}/{action}/auth/submit`
+*/
+function attachHono({ app, prefix, action, handlers }) {
+	const pathname = `${prefix}/${action}/auth`;
+	const { generateSession, checkSession, expireSession, onAuthRequest, onAuthResponse, ensureContext, ensureSignedJson } = handlers;
+	app.use(`${prefix}/${action}/*`, async (c, next) => {
+		c.header("Access-Control-Allow-Origin", "*");
+		c.header("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+		c.header("Access-Control-Allow-Headers", "Content-Type, Authorization");
+		if (c.req.method === "OPTIONS") return c.text("", 204);
+		await next();
+	});
+	app.get(`${prefix}/${action}/token`, wrapHandler([], generateSession));
+	app.post(`${prefix}/${action}/token`, wrapHandler([], generateSession));
+	app.get(`${prefix}/${action}/status`, wrapHandler([ensureContext], checkSession));
+	app.get(`${prefix}/${action}/timeout`, wrapHandler([ensureContext], expireSession));
+	app.get(pathname, wrapHandler([ensureContext, ensureSignedJson], onAuthRequest));
+	app.post(pathname, wrapHandler([ensureContext, ensureSignedJson], onAuthResponse));
+	app.get(`${pathname}/submit`, wrapHandler([ensureContext, ensureSignedJson], onAuthResponse));
+	return {
+		generateSession,
+		expireSession,
+		checkSession,
+		onAuthRequest,
+		onAuthResponse
+	};
+}
+
+//#endregion
+export { attachHono, createHonoRequest, createHonoResponse };

package/esm/handlers/util.d.mts

@@ -1,7 +1,9 @@
+import { ConnectRequest, ConnectResponse, NextFunction } from "../types.mjs";
+
 //#region src/handlers/util.d.ts
 declare const errors: Record<string, Record<string, string>>;
-declare const preparePathname: (path: string, req: any) => string;
-declare const prepareBaseUrl: (req: any, params?: Record<string, any>) => string;
+declare const preparePathname: (path: string, req: ConnectRequest) => string;
+declare const prepareBaseUrl: (req: ConnectRequest, params?: Record<string, any>) => string;
 declare const getStepChallenge: () => any;
 declare const parseWalletUA: (userAgent: string) => {
   os: string;
@@ -26,8 +28,8 @@ interface CreateHandlersOptions {
   authenticator: any;
   authPrincipal: any;
   persistentDynamicClaims?: boolean;
-  getSignParams?: (req: any) => any;
-  getPathName?: (pathname: string, req: any) => string;
+  getSignParams?: (req: ConnectRequest) => any;
+  getPathName?: (pathname: string, req: ConnectRequest) => string;
   options: {
     tokenKey: string;
     encKey: string;
@@ -55,13 +57,13 @@ declare function createHandlers({
   getPathName,
   options
 }: CreateHandlersOptions): {
-  generateSession: (req: any, res: any) => Promise<void>;
-  expireSession: (req: any, res: any) => Promise<void>;
-  checkSession: (req: any, res: any) => Promise<void>;
-  onAuthRequest: (req: any, res: any) => Promise<any>;
-  onAuthResponse: (req: any, res: any) => Promise<any>;
-  ensureContext: (req: any, _res: any, next: () => void) => Promise<void>;
-  ensureSignedJson: (req: any, res: any, next: () => void) => any;
+  generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+  ensureContext: (req: ConnectRequest, _res: ConnectResponse, next: NextFunction) => Promise<void>;
+  ensureSignedJson: (req: ConnectRequest, res: ConnectResponse, next: NextFunction) => void;
   createExtraParams: (locale: string, params: any, extra?: any) => any;
 };
 //#endregion

package/esm/handlers/wallet.d.mts

@@ -1,4 +1,6 @@
+import { ConnectRequest, ConnectResponse } from "../types.mjs";
 import BaseHandler from "./base.mjs";
+import "../index.mjs";
 
 //#region src/handlers/wallet.d.ts
 
@@ -107,11 +109,11 @@ declare class WalletHandlers extends BaseHandler {
     authPrincipal?: boolean | string | any;
     persistentDynamicClaims?: boolean;
   }): {
-    generateSession: (req: any, res: any) => Promise<void>;
-    expireSession: (req: any, res: any) => Promise<void>;
-    checkSession: (req: any, res: any) => Promise<void>;
-    onAuthRequest: (req: any, res: any) => Promise<any>;
-    onAuthResponse: (req: any, res: any) => Promise<any>;
+    generateSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+    expireSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+    checkSession: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+    onAuthRequest: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
+    onAuthResponse: (req: ConnectRequest, res: ConnectResponse) => Promise<void>;
   };
 }
 //#endregion

package/esm/handlers/wallet.mjs

@@ -1,8 +1,10 @@
 import { __require } from "../_virtual/rolldown_runtime.mjs";
 import { require_package } from "../package.mjs";
+import { isHonoApp } from "../adapters/detect.mjs";
+import { attachExpress } from "../adapters/express.mjs";
+import { attachHono } from "../adapters/hono.mjs";
 import base_default from "./base.mjs";
 import createHandlers from "./util.mjs";
-import cors from "cors";
 
 //#region src/handlers/wallet.ts
 const debug = __require("debug")(`${require_package().name}:handlers:wallet`);
@@ -108,24 +110,27 @@ var WalletHandlers = class extends base_default {
 			tokenStorage: this.tokenStorage,
 			authenticator: this.authenticator
 		});
-		app.use(`${prefix}/${action}`, cors({
-			origin: "*",
-			optionsSuccessStatus: 204
-		}));
-		app.get(`${prefix}/${action}/token`, generateSession);
-		app.post(`${prefix}/${action}/token`, generateSession);
-		app.get(`${prefix}/${action}/status`, ensureContext, checkSession);
-		app.get(`${prefix}/${action}/timeout`, ensureContext, expireSession);
-		app.get(pathname, ensureContext, ensureSignedJson, onAuthRequest);
-		app.post(pathname, ensureContext, ensureSignedJson, onAuthResponse);
-		app.get(`${pathname}/submit`, ensureContext, ensureSignedJson, onAuthResponse);
-		return {
+		const handlerFns = {
 			generateSession,
-			expireSession,
 			checkSession,
+			expireSession,
 			onAuthRequest,
-			onAuthResponse
+			onAuthResponse,
+			ensureContext,
+			ensureSignedJson
 		};
+		if (isHonoApp(app)) return attachHono({
+			app,
+			prefix,
+			action,
+			handlers: handlerFns
+		});
+		return attachExpress({
+			app,
+			prefix,
+			action,
+			handlers: handlerFns
+		});
 	}
 };
 var wallet_default = WalletHandlers;

package/esm/index.d.mts

@@ -1,3 +1,8 @@
+import { isExpressApp, isHonoApp } from "./adapters/detect.mjs";
+import { ConnectRequest, ConnectResponse, NextFunction } from "./types.mjs";
+import { attachExpress } from "./adapters/express.mjs";
+import { attachHono, createHonoRequest, createHonoResponse } from "./adapters/hono.mjs";
 import WalletAuthenticator from "./authenticator/wallet.mjs";
+import CloudflareKVStorage from "./storage/kv.mjs";
 import WalletHandlers from "./handlers/wallet.mjs";
-export { WalletAuthenticator, WalletHandlers };
+export { CloudflareKVStorage, type ConnectRequest, type ConnectResponse, type NextFunction, WalletAuthenticator, WalletHandlers, attachExpress, attachHono, createHonoRequest, createHonoResponse, isExpressApp, isHonoApp };

package/esm/index.mjs

@@ -1,4 +1,8 @@
 import wallet_default from "./authenticator/wallet.mjs";
+import { isExpressApp, isHonoApp } from "./adapters/detect.mjs";
+import { attachExpress } from "./adapters/express.mjs";
+import { attachHono, createHonoRequest, createHonoResponse } from "./adapters/hono.mjs";
 import wallet_default$1 from "./handlers/wallet.mjs";
+import kv_default from "./storage/kv.mjs";
 
-export { wallet_default as WalletAuthenticator, wallet_default$1 as WalletHandlers };
+export { kv_default as CloudflareKVStorage, wallet_default as WalletAuthenticator, wallet_default$1 as WalletHandlers, attachExpress, attachHono, createHonoRequest, createHonoResponse, isExpressApp, isHonoApp };

package/esm/package.mjs

@@ -46,6 +46,7 @@ var require_package = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			"axios": "^1.13.4",
 			"remark-cli": "^10.0.1",
 			"remark-preset-github": "^4.0.4",
+			"hono": "^4.7.0",
 			"tsdown": "^0.18.4",
 			"tweetnacl": "^1.0.3"
 		},

package/esm/storage/kv.d.mts

@@ -0,0 +1,33 @@
+import { EventEmitter } from "events";
+
+//#region src/storage/kv.d.ts
+interface KVNamespace {
+  get(key: string): Promise<string | null>;
+  put(key: string, value: string, options?: {
+    expirationTtl?: number;
+  }): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+interface CloudflareKVStorageOptions {
+  /** TTL in seconds for KV entries. Default: 300 (5 minutes) */
+  ttl?: number;
+  /** Key prefix for KV entries. Default: '' */
+  prefix?: string;
+}
+declare class CloudflareKVStorage extends EventEmitter {
+  private kv;
+  private ttl;
+  private prefix;
+  constructor(kv: KVNamespace, options?: CloudflareKVStorageOptions);
+  private key;
+  create(token: string, status?: string): Promise<{
+    token: string;
+    status: string;
+  }>;
+  read(token: string): Promise<any>;
+  update(token: string, updates: Record<string, any>): Promise<any>;
+  delete(token: string): Promise<void>;
+  exist(token: string, did?: string): Promise<boolean>;
+}
+//#endregion
+export { CloudflareKVStorage as default };

package/esm/storage/kv.mjs

@@ -0,0 +1,55 @@
+import { EventEmitter } from "events";
+
+//#region src/storage/kv.ts
+var CloudflareKVStorage = class extends EventEmitter {
+	constructor(kv, options = {}) {
+		super();
+		this.kv = kv;
+		this.ttl = options.ttl ?? 300;
+		this.prefix = options.prefix ?? "";
+	}
+	key(token) {
+		return `${this.prefix}${token}`;
+	}
+	async create(token, status = "created") {
+		const record = {
+			token,
+			status
+		};
+		await this.kv.put(this.key(token), JSON.stringify(record), { expirationTtl: this.ttl });
+		this.emit("create", record);
+		return record;
+	}
+	async read(token) {
+		const raw = await this.kv.get(this.key(token));
+		if (!raw) return null;
+		return JSON.parse(raw);
+	}
+	async update(token, updates) {
+		const existing = await this.read(token);
+		if (!existing) return null;
+		delete updates.token;
+		const merged = {
+			...existing,
+			...updates
+		};
+		await this.kv.put(this.key(token), JSON.stringify(merged), { expirationTtl: this.ttl });
+		this.emit("update", merged);
+		return merged;
+	}
+	async delete(token) {
+		const existing = await this.read(token);
+		if (existing) this.emit("destroy", existing);
+		await this.kv.delete(this.key(token));
+	}
+	async exist(token, did) {
+		const record = await this.read(token);
+		if (!record) return false;
+		if (did) return record.did === did;
+		return true;
+	}
+};
+var kv_default = CloudflareKVStorage;
+
+//#endregion
+export { kv_default as default };

package/esm/types.d.mts

@@ -0,0 +1,55 @@
+//#region src/types.d.ts
+/**
+ * Framework-agnostic request interface for DID Connect handlers.
+ *
+ * Designed to match Express's `req` shape so that Express requests
+ * satisfy it natively (zero-wrapping). Hono adapter creates a wrapper
+ * that maps Hono Context to this interface.
+ */
+interface ConnectRequest {
+  /** Parsed request body (from body-parser or Hono) */
+  body: Record<string, any>;
+  /** Parsed query string parameters */
+  query: Record<string, any>;
+  /** URL path parameters (e.g. :action) */
+  params: Record<string, any>;
+  /** Raw request headers */
+  headers: Record<string, string | string[] | undefined>;
+  /** Parsed cookies (from cookie-parser or manual parsing) */
+  cookies: Record<string, string>;
+  /** Request protocol ('http' or 'https') */
+  protocol: string;
+  /** Full original URL including query string */
+  originalUrl: string;
+  /** Session context, populated by ensureContext middleware */
+  context?: any;
+  /** Flag to prevent double monkey-patching in ensureSignedJson */
+  ensureSignedJson?: boolean;
+  /** Case-insensitive header getter (matches Express req.get) */
+  get(name: string): string | undefined;
+  /** Content negotiation for locale (matches Express req.acceptsLanguages) */
+  acceptsLanguages(...languages: string[]): string | false;
+  /** Original framework-specific request object (Express req or Hono Context) */
+  raw?: any;
+}
+/**
+ * Framework-agnostic response interface for DID Connect handlers.
+ *
+ * Express: maps directly to res.jsonp/res.json/res.status().json().
+ * Hono: uses a buffer pattern — calls are captured, then the outer
+ * Hono handler reads the buffer to return c.json().
+ */
+interface ConnectResponse {
+  /** Send JSON response (Express JSONP, Hono json) */
+  jsonp(data: any): void;
+  /** Send JSON response */
+  json(data: any): void;
+  /** Set status code and return object with json() method */
+  status(code: number): {
+    json(data: any): void;
+  };
+}
+/** Middleware next() callback */
+type NextFunction = () => void;
+//#endregion
+export { ConnectRequest, ConnectResponse, NextFunction };

package/esm/types.mjs

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

package/lib/adapters/detect.cjs

@@ -0,0 +1,18 @@
+
+//#region src/adapters/detect.ts
+/**
+* Detect whether an app object is Express or Hono.
+*
+* Express: has set(), engine(), and lazyrouter() or _router
+* Hono: has fetch() method + basePath property, no Express set/engine
+*/
+function isExpressApp(app) {
+	return typeof app?.set === "function" && typeof app?.engine === "function";
+}
+function isHonoApp(app) {
+	return typeof app?.fetch === "function" && !isExpressApp(app);
+}
+
+//#endregion
+exports.isExpressApp = isExpressApp;
+exports.isHonoApp = isHonoApp;

package/lib/adapters/detect.d.cts

@@ -0,0 +1,11 @@
+//#region src/adapters/detect.d.ts
+/**
+ * Detect whether an app object is Express or Hono.
+ *
+ * Express: has set(), engine(), and lazyrouter() or _router
+ * Hono: has fetch() method + basePath property, no Express set/engine
+ */
+declare function isExpressApp(app: any): boolean;
+declare function isHonoApp(app: any): boolean;
+//#endregion
+export { isExpressApp, isHonoApp };