@suveren/gateway 0.13.0 → 0.13.1

package/node_modules/@hap/core/dist/index.js

@@ -72,6 +72,7 @@ __export(index_exports, {
   signApproval: () => signApproval,
   signMandateProjection: () => signMandateProjection,
   validateBoundsParams: () => validateBoundsParams,
+  validateBoundsRequiredFor: () => validateBoundsRequiredFor,
   validateContextParams: () => validateContextParams,
   validateFrameParams: () => validateFrameParams,
   validateSubject: () => validateSubject,
@@ -378,6 +379,38 @@ function validateContextParams(params, profile) {
   }
   return { valid: errors.length === 0, errors };
 }
+function validateBoundsRequiredFor(profile) {
+  const errors = [];
+  const boundsSchema = profile.boundsSchema;
+  if (!boundsSchema) return errors;
+  const actionTypes = boundsSchema.actionTypes ? [...boundsSchema.actionTypes] : void 0;
+  for (const [fieldName, fieldDef] of Object.entries(boundsSchema.fields)) {
+    const bt = fieldDef.boundType;
+    if (!bt) continue;
+    const requiredFor = bt.requiredFor;
+    if (requiredFor === void 0) continue;
+    if (!Array.isArray(requiredFor) || !requiredFor.every((v) => typeof v === "string")) {
+      errors.push(`Bound "${fieldName}": requiredFor must be a string array.`);
+      continue;
+    }
+    if (bt.kind !== "per_transaction") {
+      errors.push(
+        `Bound "${fieldName}": requiredFor is only meaningful on a per_transaction bound (found on kind "${bt.kind}") \u2014 every enforcement point ignores it there. Remove it.`
+      );
+      continue;
+    }
+    if (actionTypes) {
+      for (const actionType of requiredFor) {
+        if (!actionTypes.includes(actionType)) {
+          errors.push(
+            `Bound "${fieldName}": requiredFor names action type "${actionType}", which is not in this profile's boundsSchema.actionTypes registry [${actionTypes.join(", ")}]. It can never match a real execution and the requirement is dead.`
+          );
+        }
+      }
+    }
+  }
+  return errors;
+}
 var CanonicalValueError = class extends Error {
   code;
   field;
@@ -820,6 +853,22 @@ function checkBoundsV4(request, profile, executionLog, now) {
     switch (bt.kind) {
       case "per_transaction": {
         const actual = request.execution[bt.of];
+        const engaged = !!bt.requiredFor?.length && actionType !== void 0 && bt.requiredFor.includes(actionType);
+        if (engaged) {
+          const missing = actual === void 0 || actual === null;
+          const numericActual = missing ? NaN : typeof actual === "number" ? actual : Number(actual);
+          const missingOrNonNumeric = missing || Number.isNaN(numericActual);
+          if (missingOrNonNumeric) {
+            errors.push({
+              code: "BOUND_EXCEEDED",
+              field: bt.of,
+              message: missing ? `Bound "${fieldName}" requires "${bt.of}" for "${actionType}" calls, but this call exposes no ${bt.of} to check against it. Refusing: the call cannot be shown to stay within ${fieldName}.` : `Bound "${fieldName}" requires a numeric "${bt.of}" for "${actionType}" calls, but this call's value (${String(actual)}) is not a number. Refusing: the call cannot be shown to stay within ${fieldName}.`,
+              bound: boundValue,
+              actual
+            });
+            continue;
+          }
+        }
         if (actual === void 0) continue;
         if (typeof boundValue !== "number" || typeof actual !== "number") {
           errors.push({
@@ -1266,6 +1315,7 @@ async function verifyReceiptSignature(receipt, publicKeyHex) {
   signApproval,
   signMandateProjection,
   validateBoundsParams,
+  validateBoundsRequiredFor,
   validateContextParams,
   validateFrameParams,
   validateSubject,

package/node_modules/@hap/core/dist/index.mjs

@@ -287,6 +287,38 @@ function validateContextParams(params, profile) {
   }
   return { valid: errors.length === 0, errors };
 }
+function validateBoundsRequiredFor(profile) {
+  const errors = [];
+  const boundsSchema = profile.boundsSchema;
+  if (!boundsSchema) return errors;
+  const actionTypes = boundsSchema.actionTypes ? [...boundsSchema.actionTypes] : void 0;
+  for (const [fieldName, fieldDef] of Object.entries(boundsSchema.fields)) {
+    const bt = fieldDef.boundType;
+    if (!bt) continue;
+    const requiredFor = bt.requiredFor;
+    if (requiredFor === void 0) continue;
+    if (!Array.isArray(requiredFor) || !requiredFor.every((v) => typeof v === "string")) {
+      errors.push(`Bound "${fieldName}": requiredFor must be a string array.`);
+      continue;
+    }
+    if (bt.kind !== "per_transaction") {
+      errors.push(
+        `Bound "${fieldName}": requiredFor is only meaningful on a per_transaction bound (found on kind "${bt.kind}") \u2014 every enforcement point ignores it there. Remove it.`
+      );
+      continue;
+    }
+    if (actionTypes) {
+      for (const actionType of requiredFor) {
+        if (!actionTypes.includes(actionType)) {
+          errors.push(
+            `Bound "${fieldName}": requiredFor names action type "${actionType}", which is not in this profile's boundsSchema.actionTypes registry [${actionTypes.join(", ")}]. It can never match a real execution and the requirement is dead.`
+          );
+        }
+      }
+    }
+  }
+  return errors;
+}
 var CanonicalValueError = class extends Error {
   code;
   field;
@@ -729,6 +761,22 @@ function checkBoundsV4(request, profile, executionLog, now) {
     switch (bt.kind) {
       case "per_transaction": {
         const actual = request.execution[bt.of];
+        const engaged = !!bt.requiredFor?.length && actionType !== void 0 && bt.requiredFor.includes(actionType);
+        if (engaged) {
+          const missing = actual === void 0 || actual === null;
+          const numericActual = missing ? NaN : typeof actual === "number" ? actual : Number(actual);
+          const missingOrNonNumeric = missing || Number.isNaN(numericActual);
+          if (missingOrNonNumeric) {
+            errors.push({
+              code: "BOUND_EXCEEDED",
+              field: bt.of,
+              message: missing ? `Bound "${fieldName}" requires "${bt.of}" for "${actionType}" calls, but this call exposes no ${bt.of} to check against it. Refusing: the call cannot be shown to stay within ${fieldName}.` : `Bound "${fieldName}" requires a numeric "${bt.of}" for "${actionType}" calls, but this call's value (${String(actual)}) is not a number. Refusing: the call cannot be shown to stay within ${fieldName}.`,
+              bound: boundValue,
+              actual
+            });
+            continue;
+          }
+        }
         if (actual === void 0) continue;
         if (typeof boundValue !== "number" || typeof actual !== "number") {
           errors.push({
@@ -1174,6 +1222,7 @@ export {
   signApproval,
   signMandateProjection,
   validateBoundsParams,
+  validateBoundsRequiredFor,
   validateContextParams,
   validateFrameParams,
   validateSubject,

package/node_modules/@hap/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@humanagencyp/hap-core",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Core types, cryptographic primitives, and verification logic for the Human Agency Protocol",
   "license": "MIT",
   "repository": {

package/node_modules/@hap/core/src/frame.ts

@@ -13,7 +13,7 @@
  */
 
 import { createHash } from 'crypto';
-import type { AgentFrameParams, AgentBoundsParams, AgentContextParams, AgentProfile } from './types';
+import type { AgentFrameParams, AgentBoundsParams, AgentContextParams, AgentProfile, BoundType } from './types';
 
 // ─── v0.3 Frame Functions ─────────────────────────────────────────────────────
 
@@ -179,6 +179,68 @@ export function validateContextParams(
   return { valid: errors.length === 0, errors };
 }
 
+/**
+ * Authoring-time check for `per_transaction` bound `requiredFor` (v0.8+):
+ * entries must name a real `action_type` from the profile's declared
+ * `boundsSchema.actionTypes` registry, and the field is only meaningful on
+ * `per_transaction` bounds (see `BoundType`'s doc comment for why the other
+ * kinds don't carry it).
+ *
+ * This is NOT wired into `registerProfile` or any enforcement path — nothing
+ * in hap-core validates profile JSON at load time today (the pre-existing
+ * `requiredFor` on a context/scope constraint has the same gap), so adding
+ * an automatic refusal here would be new behaviour beyond this change's
+ * scope. Call it explicitly from an authoring tool, a hap-profiles CI check,
+ * or a test, to catch a `requiredFor` entry that can never match (misspelled
+ * action type) or is attached to a bound kind that silently ignores it.
+ *
+ * Returns an empty array when the profile has no boundsSchema or nothing to
+ * check — never throws.
+ */
+export function validateBoundsRequiredFor(profile: AgentProfile): string[] {
+  const errors: string[] = [];
+  const boundsSchema = profile.boundsSchema;
+  if (!boundsSchema) return errors;
+
+  const actionTypes = boundsSchema.actionTypes ? [...boundsSchema.actionTypes] : undefined;
+
+  for (const [fieldName, fieldDef] of Object.entries(boundsSchema.fields)) {
+    const bt = fieldDef.boundType as (BoundType & { requiredFor?: unknown }) | undefined;
+    if (!bt) continue;
+    const requiredFor = (bt as { requiredFor?: unknown }).requiredFor;
+    if (requiredFor === undefined) continue;
+
+    if (!Array.isArray(requiredFor) || !requiredFor.every((v) => typeof v === 'string')) {
+      errors.push(`Bound "${fieldName}": requiredFor must be a string array.`);
+      continue;
+    }
+
+    if (bt.kind !== 'per_transaction') {
+      errors.push(
+        `Bound "${fieldName}": requiredFor is only meaningful on a per_transaction bound ` +
+        `(found on kind "${bt.kind}") — every enforcement point ignores it there. Remove it.`,
+      );
+      continue;
+    }
+
+    if (actionTypes) {
+      for (const actionType of requiredFor) {
+        if (!actionTypes.includes(actionType)) {
+          errors.push(
+            `Bound "${fieldName}": requiredFor names action type "${actionType}", which is not ` +
+            `in this profile's boundsSchema.actionTypes registry [${actionTypes.join(', ')}]. ` +
+            `It can never match a real execution and the requirement is dead.`,
+          );
+        }
+      }
+    }
+    // No actionTypes registry declared: membership cannot be checked (same
+    // tolerance the AS receipt route applies to pre-registry profiles).
+  }
+
+  return errors;
+}
+
 // ─── Value Encoding (normative, v0.5+) ───────────────────────────────────────
 
 /**

package/node_modules/@hap/core/src/gatekeeper.ts

@@ -546,6 +546,43 @@ function checkBoundsV4(
     switch (bt.kind) {
       case 'per_transaction': {
         const actual = request.execution[bt.of];
+
+        // `requiredFor`: for a listed action_type, absence (or a non-numeric
+        // value) is a denial, not a skip — see BoundType.per_transaction's
+        // doc comment for why. Unlisted action types, or no `requiredFor` at
+        // all, keep the pre-existing skip-on-absence behaviour below.
+        const engaged = !!bt.requiredFor?.length
+          && actionType !== undefined
+          && bt.requiredFor.includes(actionType);
+
+        if (engaged) {
+          // `null` is treated as "missing", not as the number 0 — JSON has no
+          // undefined, so a value lost somewhere upstream (an unmapped
+          // connector field serialized through JSON) commonly arrives as
+          // null. `Number(null) === 0` would otherwise read as "an amount of
+          // zero was declared and is within bound", which is the exact
+          // silent-pass this feature exists to close.
+          const missing = actual === undefined || actual === null;
+          const numericActual = missing ? NaN : (typeof actual === 'number' ? actual : Number(actual));
+          const missingOrNonNumeric = missing || Number.isNaN(numericActual);
+          if (missingOrNonNumeric) {
+            errors.push({
+              code: 'BOUND_EXCEEDED',
+              field: bt.of,
+              message: missing
+                ? `Bound "${fieldName}" requires "${bt.of}" for "${actionType}" calls, but this ` +
+                  `call exposes no ${bt.of} to check against it. Refusing: the call cannot be ` +
+                  `shown to stay within ${fieldName}.`
+                : `Bound "${fieldName}" requires a numeric "${bt.of}" for "${actionType}" calls, ` +
+                  `but this call's value (${String(actual)}) is not a number. Refusing: the call ` +
+                  `cannot be shown to stay within ${fieldName}.`,
+              bound: boundValue,
+              actual,
+            });
+            continue;
+          }
+        }
+
         if (actual === undefined) continue;
         if (typeof boundValue !== 'number' || typeof actual !== 'number') {
           errors.push({

package/node_modules/@hap/core/src/types.ts

@@ -218,8 +218,26 @@ export type BoundType =
    * Per-transaction cap. The execution context field named in `of` must
    * satisfy `execution[of] <= bound` for the current call. No cumulative
    * tracking. Used by: amount_max, recipient_max, booking_duration_max, etc.
+   *
+   * `requiredFor` (v0.8+) closes the converse: without it, a call that does
+   * not carry `of` at all is simply skipped — a 5,000 cap refuses 6,000 but
+   * permits a call that declares no value whatsoever, which is indistinguishable
+   * from an unenforced bound. The same hole, and the same fix, as
+   * `FieldConstraint.requiredFor` on a scope constraint (below): values drawn
+   * from the profile's `boundsSchema.actionTypes` registry. For a listed
+   * `action_type`, an execution whose context lacks `of` — or whose value is
+   * not a finite number — MUST be refused rather than skipped. For an
+   * unlisted (or when `requiredFor` is absent) action type, today's
+   * skip-on-absence behaviour is unchanged. Meaningful only on
+   * `per_transaction`; the other `BoundType` kinds have no per-call "value
+   * exposed or not" question — `cumulative_sum`/`cumulative_count` always read
+   * from the execution log regardless of what this call declares, and `enum`
+   * is a capability flag, not a runtime value — so the field does not exist
+   * on those variants and a profile that puts it there has it silently
+   * ignored by every enforcement point (TypeScript also refuses it when the
+   * profile is authored against this type rather than raw JSON).
    */
-  | { kind: 'per_transaction'; of: string }
+  | { kind: 'per_transaction'; of: string; requiredFor?: string[] }
   /**
    * Cumulative sum within a time window. The SP maintains a running sum
    * of `execution[of]` across all prior executions in the window; the
@@ -520,6 +538,16 @@ export interface AgentProfile {
   boundsSchema?: {
     keyOrder: string[];
     fields: Record<string, ProfileBoundsField>;
+    /**
+     * v0.5+ registry of the action types this profile recognizes (e.g.
+     * `["send", "delete", "setup"]`). Every `execution.action_type` the
+     * Authority Server and gateway accept for this profile MUST be a member
+     * when the registry is declared (protocol.md → Bounds Schema, rule 2);
+     * it is also what a `per_transaction` bound's `requiredFor` draws from.
+     * Absent on profiles published before the registry existed — membership
+     * is then uncheckable, not a violation.
+     */
+    actionTypes?: readonly string[];
   };
 
   /**

package/node_modules/hono/dist/cjs/hono-base.js

@@ -176,6 +176,8 @@ var Hono = class Hono {
 	/**
 	* `.mount()` allows you to mount applications built with other frameworks into your Hono application.
 	*
+	* @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+	*
 	* @see {@link https://hono.dev/docs/api/hono#mount}
 	*
 	* @param {string} path - base Path

package/node_modules/hono/dist/cjs/middleware/language/language.js

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_helper_cookie_index = require("../../helper/cookie/index.js");
 const require_utils_accept = require("../../utils/accept.js");
+const require_helper_cookie_index = require("../../helper/cookie/index.js");
 //#region src/middleware/language/language.ts
 const DEFAULT_OPTIONS = {
 	order: [

package/node_modules/hono/dist/cjs/middleware/mount/index.js

@@ -0,0 +1,71 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_helper_route_index = require("../../helper/route/index.js");
+//#region src/middleware/mount/index.ts
+const defaultReplaceRequest = (c) => {
+	const pathPrefix = require_helper_route_index.routePath(c).replace(/\/\*$/, "");
+	const url = new URL(c.req.raw.url);
+	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
+	return new Request(url, c.req.raw);
+};
+const defaultGetOptions = (c) => {
+	let executionContext = void 0;
+	try {
+		executionContext = c.executionCtx;
+	} catch {}
+	return [c.env, executionContext];
+};
+/**
+* `mount()` allows you to mount applications built with other frameworks into your Hono application.
+*
+* @see {@link https://hono.dev/docs/api/hono#mount}
+*
+* @param {Function} applicationHandler - other Request Handler
+* @param {MountOptions} [options] - options of `mount()`
+* @returns {MiddlewareHandler} handler to register with `app.all()`
+*
+* @example
+* ```ts
+* import { Router as IttyRouter } from 'itty-router'
+* import { Hono } from 'hono'
+* import { mount } from 'hono/mount'
+* // Create itty-router application
+* const ittyRouter = IttyRouter()
+* // GET /itty-router/hello
+* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+*
+* const app = new Hono()
+* app.all('/itty-router/*', mount(ittyRouter.handle))
+* ```
+*
+* @example
+* ```ts
+* const app = new Hono()
+* // Send the request to another application without modification.
+* app.all('/app/*', mount(anotherApp, {
+*   replaceRequest: (req) => req,
+* }))
+* ```
+*/
+const mount = (applicationHandler, options) => {
+	let replaceRequest;
+	let optionHandler;
+	if (options) {
+		if (typeof options === "function") optionHandler = options;
+		else {
+			optionHandler = options.optionHandler;
+			if (options.replaceRequest === false) replaceRequest = (request) => request;
+			else replaceRequest = options.replaceRequest;
+		}
+	}
+	const getOptions = optionHandler ? (c) => {
+		const options = optionHandler(c);
+		return Array.isArray(options) ? options : [options];
+	} : defaultGetOptions;
+	return async (c, next) => {
+		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+		if (res) return res;
+		await next();
+	};
+};
+//#endregion
+exports.mount = mount;

package/node_modules/hono/dist/cjs/request.js

@@ -189,7 +189,7 @@ var HonoRequest = class {
 		return this.#validatedData?.[target];
 	}
 	/**
-	* `.url()` can get the request url strings.
+	* `.url` can get the request url strings.
 	*
 	* @see {@link https://hono.dev/docs/api/request#url}
 	*
@@ -205,7 +205,7 @@ var HonoRequest = class {
 		return this.raw.url;
 	}
 	/**
-	* `.method()` can get the method name of the request.
+	* `.method` can get the method name of the request.
 	*
 	* @see {@link https://hono.dev/docs/api/request#method}
 	*
@@ -223,7 +223,7 @@ var HonoRequest = class {
 		return this.#matchResult;
 	}
 	/**
-	* `.matchedRoutes()` can return a matched route in the handler
+	* `.matchedRoutes` can return a matched route in the handler
 	*
 	* @deprecated
 	*
@@ -253,7 +253,7 @@ var HonoRequest = class {
 		return this.#matchResult[0].map(([[, route]]) => route);
 	}
 	/**
-	* `routePath()` can retrieve the path registered within the handler
+	* `.routePath` can retrieve the path registered within the handler
 	*
 	* @deprecated
 	*

package/node_modules/hono/dist/hono-base.js

@@ -175,6 +175,8 @@ var Hono = class Hono {
 	/**
 	* `.mount()` allows you to mount applications built with other frameworks into your Hono application.
 	*
+	* @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+	*
 	* @see {@link https://hono.dev/docs/api/hono#mount}
 	*
 	* @param {string} path - base Path

package/node_modules/hono/dist/middleware/mount/index.js

@@ -0,0 +1,70 @@
+import { routePath } from "../../helper/route/index.js";
+//#region src/middleware/mount/index.ts
+const defaultReplaceRequest = (c) => {
+	const pathPrefix = routePath(c).replace(/\/\*$/, "");
+	const url = new URL(c.req.raw.url);
+	url.pathname = c.req.path.slice(pathPrefix.length) || "/";
+	return new Request(url, c.req.raw);
+};
+const defaultGetOptions = (c) => {
+	let executionContext = void 0;
+	try {
+		executionContext = c.executionCtx;
+	} catch {}
+	return [c.env, executionContext];
+};
+/**
+* `mount()` allows you to mount applications built with other frameworks into your Hono application.
+*
+* @see {@link https://hono.dev/docs/api/hono#mount}
+*
+* @param {Function} applicationHandler - other Request Handler
+* @param {MountOptions} [options] - options of `mount()`
+* @returns {MiddlewareHandler} handler to register with `app.all()`
+*
+* @example
+* ```ts
+* import { Router as IttyRouter } from 'itty-router'
+* import { Hono } from 'hono'
+* import { mount } from 'hono/mount'
+* // Create itty-router application
+* const ittyRouter = IttyRouter()
+* // GET /itty-router/hello
+* ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+*
+* const app = new Hono()
+* app.all('/itty-router/*', mount(ittyRouter.handle))
+* ```
+*
+* @example
+* ```ts
+* const app = new Hono()
+* // Send the request to another application without modification.
+* app.all('/app/*', mount(anotherApp, {
+*   replaceRequest: (req) => req,
+* }))
+* ```
+*/
+const mount = (applicationHandler, options) => {
+	let replaceRequest;
+	let optionHandler;
+	if (options) {
+		if (typeof options === "function") optionHandler = options;
+		else {
+			optionHandler = options.optionHandler;
+			if (options.replaceRequest === false) replaceRequest = (request) => request;
+			else replaceRequest = options.replaceRequest;
+		}
+	}
+	const getOptions = optionHandler ? (c) => {
+		const options = optionHandler(c);
+		return Array.isArray(options) ? options : [options];
+	} : defaultGetOptions;
+	return async (c, next) => {
+		const res = await applicationHandler(replaceRequest ? replaceRequest(c.req.raw) : defaultReplaceRequest(c), ...getOptions(c));
+		if (res) return res;
+		await next();
+	};
+};
+//#endregion
+export { mount };

package/node_modules/hono/dist/request.js

@@ -188,7 +188,7 @@ var HonoRequest = class {
 		return this.#validatedData?.[target];
 	}
 	/**
-	* `.url()` can get the request url strings.
+	* `.url` can get the request url strings.
 	*
 	* @see {@link https://hono.dev/docs/api/request#url}
 	*
@@ -204,7 +204,7 @@ var HonoRequest = class {
 		return this.raw.url;
 	}
 	/**
-	* `.method()` can get the method name of the request.
+	* `.method` can get the method name of the request.
 	*
 	* @see {@link https://hono.dev/docs/api/request#method}
 	*
@@ -222,7 +222,7 @@ var HonoRequest = class {
 		return this.#matchResult;
 	}
 	/**
-	* `.matchedRoutes()` can return a matched route in the handler
+	* `.matchedRoutes` can return a matched route in the handler
 	*
 	* @deprecated
 	*
@@ -252,7 +252,7 @@ var HonoRequest = class {
 		return this.#matchResult[0].map(([[, route]]) => route);
 	}
 	/**
-	* `routePath()` can retrieve the path registered within the handler
+	* `.routePath` can retrieve the path registered within the handler
 	*
 	* @deprecated
 	*

package/node_modules/hono/dist/types/hono-base.d.ts

@@ -140,6 +140,8 @@ declare class Hono<E extends Env = Env, S extends Schema = {}, BasePath extends
   /**
    * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
    *
+   * @deprecated Use `mount()` from `hono/mount` instead. `.mount()` will be removed in v5.
+   *
    * @see {@link https://hono.dev/docs/api/hono#mount}
    *
    * @param {string} path - base Path

package/node_modules/hono/dist/types/jsx/base.d.ts

@@ -4,7 +4,7 @@ import { JSX as JSX$1 } from "./intrinsic-elements.js";
 import { Context } from "./context.js";
 //#region src/jsx/base.d.ts
 export type Props = Record<string, any>;
-type FunctionComponentResult = HtmlEscapedString | Child[] | Promise<HtmlEscapedString | Child[]> | null;
+type FunctionComponentResult = HtmlEscapedString | JSXNode | Child[] | Promise<HtmlEscapedString | JSXNode | Child[]> | null;
 export type FC<P = Props> = {
   (props: P): FunctionComponentResult;
   defaultProps?: Partial<P> | undefined;

package/node_modules/hono/dist/types/middleware/mount/index.d.ts

@@ -0,0 +1,46 @@
+import { MiddlewareHandler } from "../../types.js";
+import { Context } from "../../context.js";
+//#region src/middleware/mount/index.d.ts
+type ApplicationHandler = (request: Request, ...args: any) => Response | Promise<Response>;
+type MountOptionHandler = (c: Context) => unknown;
+type MountReplaceRequest = (originalRequest: Request) => Request;
+type MountOptions = MountOptionHandler | {
+  optionHandler?: MountOptionHandler;
+  replaceRequest?: MountReplaceRequest | false;
+};
+/**
+ * `mount()` allows you to mount applications built with other frameworks into your Hono application.
+ *
+ * @see {@link https://hono.dev/docs/api/hono#mount}
+ *
+ * @param {Function} applicationHandler - other Request Handler
+ * @param {MountOptions} [options] - options of `mount()`
+ * @returns {MiddlewareHandler} handler to register with `app.all()`
+ *
+ * @example
+ * ```ts
+ * import { Router as IttyRouter } from 'itty-router'
+ * import { Hono } from 'hono'
+ * import { mount } from 'hono/mount'
+ * // Create itty-router application
+ * const ittyRouter = IttyRouter()
+ * // GET /itty-router/hello
+ * ittyRouter.get('/hello', () => new Response('Hello from itty-router'))
+ *
+ * const app = new Hono()
+ * app.all('/itty-router/*', mount(ittyRouter.handle))
+ * ```
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ * // Send the request to another application without modification.
+ * app.all('/app/*', mount(anotherApp, {
+ *   replaceRequest: (req) => req,
+ * }))
+ * ```
+ */
+export declare const mount: (applicationHandler: ApplicationHandler, options?: MountOptions) => MiddlewareHandler;
+//#endregion
+export type { ApplicationHandler, MountOptionHandler, MountOptions, MountReplaceRequest };
+export {};

package/node_modules/hono/dist/types/request.d.ts

@@ -217,7 +217,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
    */
   valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
   /**
-   * `.url()` can get the request url strings.
+   * `.url` can get the request url strings.
    *
    * @see {@link https://hono.dev/docs/api/request#url}
    *
@@ -231,7 +231,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
    */
   get url(): string;
   /**
-   * `.method()` can get the method name of the request.
+   * `.method` can get the method name of the request.
    *
    * @see {@link https://hono.dev/docs/api/request#method}
    *
@@ -245,7 +245,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
   get method(): string;
   get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
   /**
-   * `.matchedRoutes()` can return a matched route in the handler
+   * `.matchedRoutes` can return a matched route in the handler
    *
    * @deprecated
    *
@@ -273,7 +273,7 @@ export declare class HonoRequest<P extends string = '/', I extends Input['out']
    */
   get matchedRoutes(): RouterRoute[];
   /**
-   * `routePath()` can retrieve the path registered within the handler
+   * `.routePath` can retrieve the path registered within the handler
    *
    * @deprecated
    *