@ubiquity-os/plugin-sdk 3.7.0 → 3.8.0

package/dist/index.js

@@ -231,9 +231,9 @@ var Logs = class _Logs {
     const stackLines = new Error().stack?.split("\n") || [];
     if (stackLines.length > 3) {
       const callerLine = stackLines[3];
-      const match = callerLine.match(/at (\S+)/);
-      if (match) {
-        metadata.caller = match[1];
+      const match2 = callerLine.match(/at (\S+)/);
+      if (match2) {
+        metadata.caller = match2[1];
       }
     }
     return metadata;
@@ -389,9 +389,9 @@ function getErrorStatus(err) {
     if (Number.isFinite(parsed)) return parsed;
   }
   if (err instanceof Error) {
-    const match = /LLM API error:\s*(\d{3})/i.exec(err.message);
-    if (match) {
-      const parsed = Number.parseInt(match[1], 10);
+    const match2 = /LLM API error:\s*(\d{3})/i.exec(err.message);
+    if (match2) {
+      const parsed = Number.parseInt(match2[1], 10);
       if (Number.isFinite(parsed)) return parsed;
     }
   }
@@ -429,7 +429,7 @@ function transformError(context, error) {
   return logByStatus(context, String(error), { err: error });
 }
 
-// ../../node_modules/hono/dist/helper/adapter/index.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/helper/adapter/index.js
 var env = (c, runtime) => {
   const global = globalThis;
   const globalEnv = global?.process?.env;
@@ -442,6 +442,7 @@ var env = (c, runtime) => {
       return Deno.env.toObject();
     },
     workerd: () => c.env,
+    // On Fastly Compute, you can use the ConfigStore to manage user-defined data.
     fastly: () => ({}),
     other: () => ({})
   };
@@ -636,6 +637,54 @@ function getPluginOptions(options) {
 }
 
 // src/comment.ts
+var COMMAND_RESPONSE_KIND = "command-response";
+var COMMAND_RESPONSE_MARKER = `"commentKind": "${COMMAND_RESPONSE_KIND}"`;
+var COMMAND_RESPONSE_COMMENT_LIMIT = 50;
+var RECENT_COMMENTS_QUERY = `
+  query($owner: String!, $repo: String!, $number: Int!, $last: Int!) {
+    repository(owner: $owner, name: $repo) {
+      issueOrPullRequest(number: $number) {
+        __typename
+        ... on Issue {
+          comments(last: $last) {
+            nodes {
+              id
+              body
+              isMinimized
+              minimizedReason
+              author {
+                login
+              }
+            }
+          }
+        }
+        ... on PullRequest {
+          comments(last: $last) {
+            nodes {
+              id
+              body
+              isMinimized
+              minimizedReason
+              author {
+                login
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+`;
+var MINIMIZE_COMMENT_MUTATION = `
+  mutation($id: ID!, $classifier: ReportedContentClassifiers!) {
+    minimizeComment(input: { subjectId: $id, classifier: $classifier }) {
+      minimizedComment {
+        isMinimized
+        minimizedReason
+      }
+    }
+  }
+`;
 function logByStatus2(logger, message, status, metadata) {
   const payload = { ...metadata, ...status ? { status } : {} };
   if (status && status >= 500) return logger.error(message, payload);
@@ -648,6 +697,7 @@ function logByStatus2(logger, message, status, metadata) {
 var CommentHandler = class _CommentHandler {
   static HEADER_NAME = "UbiquityOS";
   _lastCommentId = { reviewCommentId: null, issueCommentId: null };
+  _commandResponsePolicyApplied = false;
   async _updateIssueComment(context, params) {
     if (!this._lastCommentId.issueCommentId) {
       throw context.logger.error("issueCommentId is missing");
@@ -702,6 +752,11 @@ var CommentHandler = class _CommentHandler {
   _getCommentId(context) {
     return "pull_request" in context.payload && "comment" in context.payload ? context.payload.comment.id : void 0;
   }
+  _getCommentNodeId(context) {
+    const payload = context.payload;
+    const nodeId = payload.comment?.node_id;
+    return typeof nodeId === "string" && nodeId.trim() ? nodeId : null;
+  }
   _extractIssueContext(context) {
     if (!("repository" in context.payload) || !context.payload.repository?.owner?.login) {
       return null;
@@ -715,6 +770,86 @@ var CommentHandler = class _CommentHandler {
       repo: context.payload.repository.name
     };
   }
+  _extractIssueLocator(context) {
+    if (!("issue" in context.payload) && !("pull_request" in context.payload)) {
+      return null;
+    }
+    const issueContext = this._extractIssueContext(context);
+    if (!issueContext) return null;
+    return {
+      owner: issueContext.owner,
+      repo: issueContext.repo,
+      issueNumber: issueContext.issueNumber
+    };
+  }
+  _shouldApplyCommandResponsePolicy(context) {
+    const payload = context;
+    return Boolean(payload.command);
+  }
+  _isCommandResponseComment(body) {
+    return typeof body === "string" && body.includes(COMMAND_RESPONSE_MARKER);
+  }
+  _getGraphqlClient(context) {
+    const graphql = context.octokit.graphql;
+    return typeof graphql === "function" ? graphql : null;
+  }
+  async _fetchRecentComments(context, locator, last = COMMAND_RESPONSE_COMMENT_LIMIT) {
+    const graphql = this._getGraphqlClient(context);
+    if (!graphql) return [];
+    try {
+      const data = await graphql(RECENT_COMMENTS_QUERY, {
+        owner: locator.owner,
+        repo: locator.repo,
+        number: locator.issueNumber,
+        last
+      });
+      const nodes = data.repository?.issueOrPullRequest?.comments?.nodes ?? [];
+      return nodes.filter((node) => Boolean(node));
+    } catch (error) {
+      context.logger.debug("Failed to fetch recent comments (non-fatal)", { err: error });
+      return [];
+    }
+  }
+  _findPreviousCommandResponseComment(comments, currentCommentId) {
+    for (let idx = comments.length - 1; idx >= 0; idx -= 1) {
+      const comment = comments[idx];
+      if (!comment) continue;
+      if (currentCommentId && comment.id === currentCommentId) continue;
+      if (this._isCommandResponseComment(comment.body)) {
+        return comment;
+      }
+    }
+    return null;
+  }
+  async _minimizeComment(context, commentNodeId, classifier = "RESOLVED") {
+    const graphql = this._getGraphqlClient(context);
+    if (!graphql) return;
+    try {
+      await graphql(MINIMIZE_COMMENT_MUTATION, {
+        id: commentNodeId,
+        classifier
+      });
+    } catch (error) {
+      context.logger.debug("Failed to minimize comment (non-fatal)", { err: error, commentNodeId });
+    }
+  }
+  async _applyCommandResponsePolicy(context) {
+    if (this._commandResponsePolicyApplied) return;
+    this._commandResponsePolicyApplied = true;
+    if (!this._shouldApplyCommandResponsePolicy(context)) return;
+    const locator = this._extractIssueLocator(context);
+    const commentNodeId = this._getCommentNodeId(context);
+    const comments = locator ? await this._fetchRecentComments(context, locator) : [];
+    const current = commentNodeId ? comments.find((comment) => comment.id === commentNodeId) : null;
+    const currentIsMinimized = current?.isMinimized ?? false;
+    if (commentNodeId && !currentIsMinimized) {
+      await this._minimizeComment(context, commentNodeId);
+    }
+    const previous = this._findPreviousCommandResponseComment(comments, commentNodeId);
+    if (previous && !previous.isMinimized) {
+      await this._minimizeComment(context, previous.id);
+    }
+  }
   _processMessage(context, message) {
     if (message instanceof Error) {
       const metadata2 = {
@@ -766,7 +901,9 @@ var CommentHandler = class _CommentHandler {
   }
   _createCommentBody(context, message, options) {
     const { metadata, logMessage } = this._processMessage(context, message);
-    const { header, jsonPretty } = this._createMetadataContent(context, metadata);
+    const shouldTagCommandResponse = options?.commentKind && typeof metadata === "object" && metadata !== null && !("commentKind" in metadata);
+    const metadataWithKind = shouldTagCommandResponse ? { ...metadata, commentKind: options?.commentKind } : metadata;
+    const { header, jsonPretty } = this._createMetadataContent(context, metadataWithKind);
     const metadataContent = this._formatMetadataContent(logMessage, header, jsonPretty);
     return `${options?.raw ? logMessage?.raw : logMessage?.diff}
 
@@ -774,12 +911,17 @@ ${metadataContent}
 `;
   }
   async postComment(context, message, options = { updateComment: true, raw: false }) {
+    await this._applyCommandResponsePolicy(context);
     const issueContext = this._extractIssueContext(context);
     if (!issueContext) {
       context.logger.warn("Cannot post comment: missing issue context in payload");
       return null;
     }
-    const body = this._createCommentBody(context, message, options);
+    const shouldTagCommandResponse = this._shouldApplyCommandResponsePolicy(context);
+    const body = this._createCommentBody(context, message, {
+      ...options,
+      commentKind: options.commentKind ?? (shouldTagCommandResponse ? COMMAND_RESPONSE_KIND : void 0)
+    });
     const { issueNumber, commentId, owner, repo } = issueContext;
     const params = { owner, repo, body, issueNumber };
     if (options.updateComment) {
@@ -1177,12 +1319,12 @@ function cleanMarkdown(md, options = {}) {
   const segments = [];
   let lastIndex = 0;
   const matches = [...md.matchAll(codeBlockRegex)];
-  for (const match of matches) {
-    if (match.index > lastIndex) {
-      segments.push(processSegment(md.slice(lastIndex, match.index), tags, shouldCollapseEmptyLines));
+  for (const match2 of matches) {
+    if (match2.index > lastIndex) {
+      segments.push(processSegment(md.slice(lastIndex, match2.index), tags, shouldCollapseEmptyLines));
     }
-    segments.push(match[0]);
-    lastIndex = match.index + match[0].length;
+    segments.push(match2[0]);
+    lastIndex = match2.index + match2[0].length;
   }
   if (lastIndex < md.length) {
     segments.push(processSegment(md.slice(lastIndex), tags, shouldCollapseEmptyLines));
@@ -1225,7 +1367,7 @@ function processSegment(segment, extraTags, shouldCollapseEmptyLines) {
 // src/server.ts
 var import_value4 = require("@sinclair/typebox/value");
 
-// ../../node_modules/hono/dist/compose.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
@@ -1269,10 +1411,43 @@ var compose = (middleware, onError, onNotFound) => {
   };
 };
 
-// ../../node_modules/hono/dist/request/constants.js
-var GET_MATCH_RESULT = Symbol();
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/http-exception.js
+var HTTPException = class extends Error {
+  res;
+  status;
+  /**
+   * Creates an instance of `HTTPException`.
+   * @param status - HTTP status code for the exception. Defaults to 500.
+   * @param options - Additional options for the exception.
+   */
+  constructor(status = 500, options) {
+    super(options?.message, { cause: options?.cause });
+    this.res = options?.res;
+    this.status = status;
+  }
+  /**
+   * Returns the response object associated with the exception.
+   * If a response object is not provided, a new response is created with the error message and status code.
+   * @returns The response object.
+   */
+  getResponse() {
+    if (this.res) {
+      const newResponse = new Response(this.res.body, {
+        status: this.status,
+        headers: this.res.headers
+      });
+      return newResponse;
+    }
+    return new Response(this.message, {
+      status: this.status
+    });
+  }
+};
+
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
 
-// ../../node_modules/hono/dist/utils/body.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/utils/body.js
 var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
   const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
@@ -1341,7 +1516,7 @@ var handleParsingNestedValues = (form, key, value) => {
   });
 };
 
-// ../../node_modules/hono/dist/utils/url.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/utils/url.js
 var splitPath = (path) => {
   const paths = path.split("/");
   if (paths[0] === "") {
@@ -1356,9 +1531,9 @@ var splitRoutingPath = (routePath) => {
 };
 var extractGroupsFromPath = (path) => {
   const groups = [];
-  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+  path = path.replace(/\{[^}]+\}/g, (match2, index) => {
     const mark = `@${index}`;
-    groups.push([mark, match]);
+    groups.push([mark, match2]);
     return mark;
   });
   return { groups, path };
@@ -1380,14 +1555,14 @@ var getPattern = (label, next) => {
   if (label === "*") {
     return "*";
   }
-  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
-  if (match) {
+  const match2 = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match2) {
     const cacheKey = `${label}#${next}`;
     if (!patternCache[cacheKey]) {
-      if (match[2]) {
-        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match[1], new RegExp(`^${match[2]}(?=/${next})`)] : [label, match[1], new RegExp(`^${match[2]}$`)];
+      if (match2[2]) {
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey, match2[1], new RegExp(`^${match2[2]}(?=/${next})`)] : [label, match2[1], new RegExp(`^${match2[2]}$`)];
       } else {
-        patternCache[cacheKey] = [label, match[1], true];
+        patternCache[cacheKey] = [label, match2[1], true];
       }
     }
     return patternCache[cacheKey];
@@ -1398,11 +1573,11 @@ var tryDecode = (str, decoder) => {
   try {
     return decoder(str);
   } catch {
-    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
       try {
-        return decoder(match);
+        return decoder(match2);
       } catch {
-        return match;
+        return match2;
       }
     });
   }
@@ -1410,10 +1585,7 @@ var tryDecode = (str, decoder) => {
 var tryDecodeURI = (str) => tryDecode(str, decodeURI);
 var getPath = (request) => {
   const url = request.url;
-  const start = url.indexOf(
-    "/",
-    url.charCodeAt(9) === 58 ? 13 : 8
-  );
+  const start = url.indexOf("/", url.indexOf(":") + 4);
   let i = start;
   for (; i < url.length; i++) {
     const charCode = url.charCodeAt(i);
@@ -1476,9 +1648,12 @@ var _decodeURI = (value) => {
 var _getQueryParam = (url, key, multiple) => {
   let encoded;
   if (!multiple && key && !/[%+]/.test(key)) {
-    let keyIndex2 = url.indexOf(`?${key}`, 8);
+    let keyIndex2 = url.indexOf("?", 8);
     if (keyIndex2 === -1) {
-      keyIndex2 = url.indexOf(`&${key}`, 8);
+      return void 0;
+    }
+    if (!url.startsWith(key, keyIndex2 + 1)) {
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
     }
     while (keyIndex2 !== -1) {
       const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
@@ -1543,13 +1718,40 @@ var getQueryParams = (url, key) => {
 };
 var decodeURIComponent_ = decodeURIComponent;
 
-// ../../node_modules/hono/dist/request.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/request.js
 var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
+  /**
+   * `.raw` can get the raw Request object.
+   *
+   * @see {@link https://hono.dev/docs/api/request#raw}
+   *
+   * @example
+   * ```ts
+   * // For Cloudflare Workers
+   * app.post('/', async (c) => {
+   *   const metadata = c.req.raw.cf?.hostMetadata?
+   *   ...
+   * })
+   * ```
+   */
   raw;
   #validatedData;
+  // Short name of validatedData
   #matchResult;
   routeIndex = 0;
+  /**
+   * `.path` can get the pathname of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#path}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const pathname = c.req.path // `/about/me`
+   * })
+   * ```
+   */
   path;
   bodyCache = {};
   constructor(request, path = "/", matchResult = [[]]) {
@@ -1564,14 +1766,14 @@ var HonoRequest = class {
   #getDecodedParam(key) {
     const paramKey = this.#matchResult[0][this.routeIndex][1][key];
     const param = this.#getParamValue(paramKey);
-    return param ? /\%/.test(param) ? tryDecodeURIComponent(param) : param : void 0;
+    return param && /\%/.test(param) ? tryDecodeURIComponent(param) : param;
   }
   #getAllDecodedParams() {
     const decoded = {};
     const keys = Object.keys(this.#matchResult[0][this.routeIndex][1]);
     for (const key of keys) {
       const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
-      if (value && typeof value === "string") {
+      if (value !== void 0) {
         decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
       }
     }
@@ -1616,45 +1818,175 @@ var HonoRequest = class {
     }
     return bodyCache[key] = raw2[key]();
   };
+  /**
+   * `.json()` can parse Request body of type `application/json`
+   *
+   * @see {@link https://hono.dev/docs/api/request#json}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.json()
+   * })
+   * ```
+   */
   json() {
     return this.#cachedBody("text").then((text) => JSON.parse(text));
   }
+  /**
+   * `.text()` can parse Request body of type `text/plain`
+   *
+   * @see {@link https://hono.dev/docs/api/request#text}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.text()
+   * })
+   * ```
+   */
   text() {
     return this.#cachedBody("text");
   }
+  /**
+   * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+   *
+   * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.arrayBuffer()
+   * })
+   * ```
+   */
   arrayBuffer() {
     return this.#cachedBody("arrayBuffer");
   }
+  /**
+   * Parses the request body as a `Blob`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.blob();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#blob
+   */
   blob() {
     return this.#cachedBody("blob");
   }
+  /**
+   * Parses the request body as `FormData`.
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.formData();
+   * });
+   * ```
+   * @see https://hono.dev/docs/api/request#formdata
+   */
   formData() {
     return this.#cachedBody("formData");
   }
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
   addValidatedData(target, data) {
     this.#validatedData[target] = data;
   }
   valid(target) {
     return this.#validatedData[target];
   }
+  /**
+   * `.url()` can get the request url strings.
+   *
+   * @see {@link https://hono.dev/docs/api/request#url}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const url = c.req.url // `http://localhost:8787/about/me`
+   *   ...
+   * })
+   * ```
+   */
   get url() {
     return this.raw.url;
   }
+  /**
+   * `.method()` can get the method name of the request.
+   *
+   * @see {@link https://hono.dev/docs/api/request#method}
+   *
+   * @example
+   * ```ts
+   * app.get('/about/me', (c) => {
+   *   const method = c.req.method // `GET`
+   * })
+   * ```
+   */
   get method() {
     return this.raw.method;
   }
   get [GET_MATCH_RESULT]() {
     return this.#matchResult;
   }
+  /**
+   * `.matchedRoutes()` can return a matched route in the handler
+   *
+   * @deprecated
+   *
+   * Use matchedRoutes helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async function logger(c, next) {
+   *   await next()
+   *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+   *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+   *     console.log(
+   *       method,
+   *       ' ',
+   *       path,
+   *       ' '.repeat(Math.max(10 - path.length, 0)),
+   *       name,
+   *       i === c.req.routeIndex ? '<- respond from here' : ''
+   *     )
+   *   })
+   * })
+   * ```
+   */
   get matchedRoutes() {
     return this.#matchResult[0].map(([[, route]]) => route);
   }
+  /**
+   * `routePath()` can retrieve the path registered within the handler
+   *
+   * @deprecated
+   *
+   * Use routePath helper defined in "hono/route" instead.
+   *
+   * @see {@link https://hono.dev/docs/api/request#routepath}
+   *
+   * @example
+   * ```ts
+   * app.get('/posts/:id', (c) => {
+   *   return c.json({ path: c.req.routePath })
+   * })
+   * ```
+   */
   get routePath() {
     return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
   }
 };
 
-// ../../node_modules/hono/dist/utils/html.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/utils/html.js
 var HtmlEscapedCallbackPhase = {
   Stringify: 1,
   BeforeStream: 2,
@@ -1696,7 +2028,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   }
 };
 
-// ../../node_modules/hono/dist/context.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/context.js
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setDefaultContentType = (contentType, headers) => {
   return {
@@ -1707,9 +2039,37 @@ var setDefaultContentType = (contentType, headers) => {
 var Context = class {
   #rawRequest;
   #req;
+  /**
+   * `.env` can get bindings (environment variables, secrets, KV namespaces, D1 database, R2 bucket etc.) in Cloudflare Workers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#env}
+   *
+   * @example
+   * ```ts
+   * // Environment object for Cloudflare Workers
+   * app.get('*', async c => {
+   *   const counter = c.env.COUNTER
+   * })
+   * ```
+   */
   env = {};
   #var;
   finalized = false;
+  /**
+   * `.error` can get the error object from the middleware if the Handler throws an error.
+   *
+   * @see {@link https://hono.dev/docs/api/context#error}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   await next()
+   *   if (c.error) {
+   *     // do something...
+   *   }
+   * })
+   * ```
+   */
   error;
   #status;
   #executionCtx;
@@ -1720,6 +2080,12 @@ var Context = class {
   #preparedHeaders;
   #matchResult;
   #path;
+  /**
+   * Creates an instance of the Context class.
+   *
+   * @param req - The Request object.
+   * @param options - Optional configuration options for the context.
+   */
   constructor(req, options) {
     this.#rawRequest = req;
     if (options) {
@@ -1730,10 +2096,19 @@ var Context = class {
       this.#matchResult = options.matchResult;
     }
   }
+  /**
+   * `.req` is the instance of {@link HonoRequest}.
+   */
   get req() {
     this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
     return this.#req;
   }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#event}
+   * The FetchEvent associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have a FetchEvent.
+   */
   get event() {
     if (this.#executionCtx && "respondWith" in this.#executionCtx) {
       return this.#executionCtx;
@@ -1741,6 +2116,12 @@ var Context = class {
       throw Error("This context has no FetchEvent");
     }
   }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#executionctx}
+   * The ExecutionContext associated with the current request.
+   *
+   * @throws Will throw an error if the context does not have an ExecutionContext.
+   */
   get executionCtx() {
     if (this.#executionCtx) {
       return this.#executionCtx;
@@ -1748,11 +2129,20 @@ var Context = class {
       throw Error("This context has no ExecutionContext");
     }
   }
+  /**
+   * @see {@link https://hono.dev/docs/api/context#res}
+   * The Response object for the current request.
+   */
   get res() {
     return this.#res ||= new Response(null, {
       headers: this.#preparedHeaders ??= new Headers()
     });
   }
+  /**
+   * Sets the Response object for the current request.
+   *
+   * @param _res - The Response object to set.
+   */
   set res(_res) {
     if (this.#res && _res) {
       _res = new Response(_res.body, _res);
@@ -1774,15 +2164,75 @@ var Context = class {
     this.#res = _res;
     this.finalized = true;
   }
+  /**
+   * `.render()` can create a response within a layout.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   return c.render('Hello!')
+   * })
+   * ```
+   */
   render = (...args) => {
     this.#renderer ??= (content) => this.html(content);
     return this.#renderer(...args);
   };
+  /**
+   * Sets the layout for the response.
+   *
+   * @param layout - The layout to set.
+   * @returns The layout function.
+   */
   setLayout = (layout) => this.#layout = layout;
+  /**
+   * Gets the current layout for the response.
+   *
+   * @returns The current layout function.
+   */
   getLayout = () => this.#layout;
+  /**
+   * `.setRenderer()` can set the layout in the custom middleware.
+   *
+   * @see {@link https://hono.dev/docs/api/context#render-setrenderer}
+   *
+   * @example
+   * ```tsx
+   * app.use('*', async (c, next) => {
+   *   c.setRenderer((content) => {
+   *     return c.html(
+   *       <html>
+   *         <body>
+   *           <p>{content}</p>
+   *         </body>
+   *       </html>
+   *     )
+   *   })
+   *   await next()
+   * })
+   * ```
+   */
   setRenderer = (renderer) => {
     this.#renderer = renderer;
   };
+  /**
+   * `.header()` can set headers.
+   *
+   * @see {@link https://hono.dev/docs/api/context#header}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
   header = (name, value, options) => {
     if (this.finalized) {
       this.#res = new Response(this.#res.body, this.#res);
@@ -1799,13 +2249,50 @@ var Context = class {
   status = (status) => {
     this.#status = status;
   };
+  /**
+   * `.set()` can set the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.use('*', async (c, next) => {
+   *   c.set('message', 'Hono is hot!!')
+   *   await next()
+   * })
+   * ```
+   */
   set = (key, value) => {
     this.#var ??= /* @__PURE__ */ new Map();
     this.#var.set(key, value);
   };
+  /**
+   * `.get()` can use the value specified by the key.
+   *
+   * @see {@link https://hono.dev/docs/api/context#set-get}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   const message = c.get('message')
+   *   return c.text(`The message is "${message}"`)
+   * })
+   * ```
+   */
   get = (key) => {
     return this.#var ? this.#var.get(key) : void 0;
   };
+  /**
+   * `.var` can access the value of a variable.
+   *
+   * @see {@link https://hono.dev/docs/api/context#var}
+   *
+   * @example
+   * ```ts
+   * const result = c.var.client.oneMethod()
+   * ```
+   */
+  // c.var.propName is a read-only
   get var() {
     if (!this.#var) {
       return {};
@@ -1840,7 +2327,40 @@ var Context = class {
     return new Response(data, { status, headers: responseHeaders });
   }
   newResponse = (...args) => this.#newResponse(...args);
+  /**
+   * `.body()` can return the HTTP response.
+   * You can set headers with `.header()` and set HTTP status code with `.status`.
+   * This can also be set in `.text()`, `.json()` and so on.
+   *
+   * @see {@link https://hono.dev/docs/api/context#body}
+   *
+   * @example
+   * ```ts
+   * app.get('/welcome', (c) => {
+   *   // Set headers
+   *   c.header('X-Message', 'Hello!')
+   *   c.header('Content-Type', 'text/plain')
+   *   // Set HTTP status code
+   *   c.status(201)
+   *
+   *   // Return the response body
+   *   return c.body('Thank you for coming')
+   * })
+   * ```
+   */
   body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  /**
+   * `.text()` can render text as `Content-Type:text/plain`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#text}
+   *
+   * @example
+   * ```ts
+   * app.get('/say', (c) => {
+   *   return c.text('Hello!')
+   * })
+   * ```
+   */
   text = (text, arg, headers) => {
     return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(
       text,
@@ -1848,6 +2368,18 @@ var Context = class {
       setDefaultContentType(TEXT_PLAIN, headers)
     );
   };
+  /**
+   * `.json()` can render JSON as `Content-Type:application/json`.
+   *
+   * @see {@link https://hono.dev/docs/api/context#json}
+   *
+   * @example
+   * ```ts
+   * app.get('/api', (c) => {
+   *   return c.json({ message: 'Hello!' })
+   * })
+   * ```
+   */
   json = (object, arg, headers) => {
     return this.#newResponse(
       JSON.stringify(object),
@@ -1859,21 +2391,50 @@ var Context = class {
     const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
     return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
   };
+  /**
+   * `.redirect()` can Redirect, default status code is 302.
+   *
+   * @see {@link https://hono.dev/docs/api/context#redirect}
+   *
+   * @example
+   * ```ts
+   * app.get('/redirect', (c) => {
+   *   return c.redirect('/')
+   * })
+   * app.get('/redirect-permanently', (c) => {
+   *   return c.redirect('/', 301)
+   * })
+   * ```
+   */
   redirect = (location, status) => {
     const locationString = String(location);
     this.header(
       "Location",
+      // Multibyes should be encoded
+      // eslint-disable-next-line no-control-regex
       !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString)
     );
     return this.newResponse(null, status ?? 302);
   };
+  /**
+   * `.notFound()` can return the Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/context#notfound}
+   *
+   * @example
+   * ```ts
+   * app.get('/notfound', (c) => {
+   *   return c.notFound()
+   * })
+   * ```
+   */
   notFound = () => {
     this.#notFoundHandler ??= () => new Response();
     return this.#notFoundHandler(this);
   };
 };
 
-// ../../node_modules/hono/dist/router.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router.js
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
 var METHODS = ["get", "post", "put", "delete", "options", "patch"];
@@ -1881,10 +2442,10 @@ var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is
 var UnsupportedPathError = class extends Error {
 };
 
-// ../../node_modules/hono/dist/utils/constants.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/utils/constants.js
 var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
 
-// ../../node_modules/hono/dist/hono-base.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/hono-base.js
 var notFoundHandler = (c) => {
   return c.text("404 Not Found", 404);
 };
@@ -1896,7 +2457,7 @@ var errorHandler = (err, c) => {
   console.error(err);
   return c.text("Internal Server Error", 500);
 };
-var Hono = class {
+var Hono = class _Hono {
   get;
   post;
   put;
@@ -1906,8 +2467,13 @@ var Hono = class {
   all;
   on;
   use;
+  /*
+    This class is like an abstract class and does not have a router.
+    To use it, inherit the class and implement router in the constructor.
+  */
   router;
   getPath;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
   _basePath = "/";
   #path = "/";
   routes = [];
@@ -1954,7 +2520,7 @@ var Hono = class {
     this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
   }
   #clone() {
-    const clone = new Hono({
+    const clone = new _Hono({
       router: this.router,
       getPath: this.getPath
     });
@@ -1964,7 +2530,26 @@ var Hono = class {
     return clone;
   }
   #notFoundHandler = notFoundHandler;
+  // Cannot use `#` because it requires visibility at JavaScript runtime.
   errorHandler = errorHandler;
+  /**
+   * `.route()` allows grouping other Hono instance in routes.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#grouping}
+   *
+   * @param {string} path - base Path
+   * @param {Hono} app - other Hono instance
+   * @returns {Hono} routed Hono instance
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * const app2 = new Hono()
+   *
+   * app2.get("/user", (c) => c.text("user"))
+   * app.route("/api", app2) // GET /api/user
+   * ```
+   */
   route(path, app) {
     const subApp = this.basePath(path);
     app.routes.map((r) => {
@@ -1979,19 +2564,95 @@ var Hono = class {
     });
     return this;
   }
+  /**
+   * `.basePath()` allows base paths to be specified.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#base-path}
+   *
+   * @param {string} path - base Path
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * const api = new Hono().basePath('/api')
+   * ```
+   */
   basePath(path) {
     const subApp = this.#clone();
     subApp._basePath = mergePath(this._basePath, path);
     return subApp;
   }
+  /**
+   * `.onError()` handles an error and returns a customized Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#error-handling}
+   *
+   * @param {ErrorHandler} handler - request Handler for error
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.onError((err, c) => {
+   *   console.error(`${err}`)
+   *   return c.text('Custom Error Message', 500)
+   * })
+   * ```
+   */
   onError = (handler) => {
     this.errorHandler = handler;
     return this;
   };
+  /**
+   * `.notFound()` allows you to customize a Not Found Response.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#not-found}
+   *
+   * @param {NotFoundHandler} handler - request handler for not-found
+   * @returns {Hono} changed Hono instance
+   *
+   * @example
+   * ```ts
+   * app.notFound((c) => {
+   *   return c.text('Custom 404 Message', 404)
+   * })
+   * ```
+   */
   notFound = (handler) => {
     this.#notFoundHandler = handler;
     return this;
   };
+  /**
+   * `.mount()` allows you to mount applications built with other frameworks into your Hono application.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#mount}
+   *
+   * @param {string} path - base Path
+   * @param {Function} applicationHandler - other Request Handler
+   * @param {MountOptions} [options] - options of `.mount()`
+   * @returns {Hono} mounted Hono instance
+   *
+   * @example
+   * ```ts
+   * import { Router as IttyRouter } from 'itty-router'
+   * import { Hono } from 'hono'
+   * // 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.mount('/itty-router', ittyRouter.handle)
+   * ```
+   *
+   * @example
+   * ```ts
+   * const app = new Hono()
+   * // Send the request to another application without modification.
+   * app.mount('/app', anotherApp, {
+   *   replaceRequest: (req) => req,
+   * })
+   * ```
+   */
   mount(path, applicationHandler, options) {
     let replaceRequest;
     let optionHandler;
@@ -2091,9 +2752,32 @@ var Hono = class {
       }
     })();
   }
+  /**
+   * `.fetch()` will be entry point of your app.
+   *
+   * @see {@link https://hono.dev/docs/api/hono#fetch}
+   *
+   * @param {Request} request - request Object of request
+   * @param {Env} Env - env Object
+   * @param {ExecutionContext} - context of execution
+   * @returns {Response | Promise<Response>} response of request
+   *
+   */
   fetch = (request, ...rest) => {
     return this.#dispatch(request, rest[1], rest[0], request.method);
   };
+  /**
+   * `.request()` is a useful method for testing.
+   * You can pass a URL or pathname to send a GET request.
+   * app will return a Response object.
+   * ```ts
+   * test('GET /hello is ok', async () => {
+   *   const res = await app.request('/hello')
+   *   expect(res.status).toBe(200)
+   * })
+   * ```
+   * @see https://hono.dev/docs/api/hono#request
+   */
   request = (input, requestInit, Env, executionCtx) => {
     if (input instanceof Request) {
       return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
@@ -2108,6 +2792,23 @@ var Hono = class {
       executionCtx
     );
   };
+  /**
+   * `.fire()` automatically adds a global fetch event listener.
+   * This can be useful for environments that adhere to the Service Worker API, such as non-ES module Cloudflare Workers.
+   * @deprecated
+   * Use `fire` from `hono/service-worker` instead.
+   * ```ts
+   * import { Hono } from 'hono'
+   * import { fire } from 'hono/service-worker'
+   *
+   * const app = new Hono()
+   * // ...
+   * fire(app)
+   * ```
+   * @see https://hono.dev/docs/api/hono#fire
+   * @see https://developer.mozilla.org/en-US/docs/Web/API/Service_Worker_API
+   * @see https://developers.cloudflare.com/workers/reference/migrate-to-module-workers/
+   */
   fire = () => {
     addEventListener("fetch", (event) => {
       event.respondWith(this.#dispatch(event.request, event, void 0, event.request.method));
@@ -2115,11 +2816,32 @@ var Hono = class {
   };
 };
 
-// ../../node_modules/hono/dist/router/reg-exp-router/node.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = ((method2, path2) => {
+    const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch) {
+      return staticMatch;
+    }
+    const match3 = path2.match(matcher[0]);
+    if (!match3) {
+      return [[], emptyParam];
+    }
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  });
+  this.match = match2;
+  return match2(method, path);
+}
+
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/node.js
 var LABEL_REG_EXP_STR = "[^/]+";
 var ONLY_WILDCARD_REG_EXP_STR = ".*";
 var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
-var PATH_ERROR = Symbol();
+var PATH_ERROR = /* @__PURE__ */ Symbol();
 var regExpMetaChars = new Set(".\\+*[^]$()");
 function compareKey(a, b) {
   if (a.length === 1) {
@@ -2140,7 +2862,7 @@ function compareKey(a, b) {
   }
   return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
 }
-var Node = class {
+var Node = class _Node {
   #index;
   #varIndex;
   #children = /* @__PURE__ */ Object.create(null);
@@ -2180,7 +2902,7 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.#children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new _Node();
         if (name !== "") {
           node.#varIndex = context.varIndex++;
         }
@@ -2199,7 +2921,7 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.#children[token] = new Node();
+        node = this.#children[token] = new _Node();
       }
     }
     node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
@@ -2223,7 +2945,7 @@ var Node = class {
   }
 };
 
-// ../../node_modules/hono/dist/router/reg-exp-router/trie.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/trie.js
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
@@ -2279,8 +3001,7 @@ var Trie = class {
   }
 };
 
-// ../../node_modules/hono/dist/router/reg-exp-router/router.js
-var emptyParam = [];
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
@@ -2427,30 +3148,14 @@ var RegExpRouter = class {
       });
     }
   }
-  match(method, path) {
-    clearWildcardRegExpCache();
-    const matchers = this.#buildAllMatchers();
-    this.match = (method2, path2) => {
-      const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
-      const staticMatch = matcher[2][path2];
-      if (staticMatch) {
-        return staticMatch;
-      }
-      const match = path2.match(matcher[0]);
-      if (!match) {
-        return [[], emptyParam];
-      }
-      const index = match.indexOf("", 1);
-      return [matcher[1][index], match];
-    };
-    return this.match(method, path);
-  }
-  #buildAllMatchers() {
+  match = match;
+  buildAllMatchers() {
     const matchers = /* @__PURE__ */ Object.create(null);
     Object.keys(this.#routes).concat(Object.keys(this.#middleware)).forEach((method) => {
       matchers[method] ||= this.#buildMatcher(method);
     });
     this.#middleware = this.#routes = void 0;
+    clearWildcardRegExpCache();
     return matchers;
   }
   #buildMatcher(method) {
@@ -2475,7 +3180,7 @@ var RegExpRouter = class {
   }
 };
 
-// ../../node_modules/hono/dist/router/smart-router/router.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/smart-router/router.js
 var SmartRouter = class {
   name = "SmartRouter";
   #routers = [];
@@ -2530,9 +3235,9 @@ var SmartRouter = class {
   }
 };
 
-// ../../node_modules/hono/dist/router/trie-router/node.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/trie-router/node.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
-var Node2 = class {
+var Node2 = class _Node2 {
   #methods;
   #children;
   #patterns;
@@ -2565,7 +3270,7 @@ var Node2 = class {
         }
         continue;
       }
-      curNode.#children[key] = new Node2();
+      curNode.#children[key] = new _Node2();
       if (pattern) {
         curNode.#patterns.push(pattern);
         possibleKeys.push(pattern[1]);
@@ -2688,7 +3393,7 @@ var Node2 = class {
   }
 };
 
-// ../../node_modules/hono/dist/router/trie-router/router.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/router/trie-router/router.js
 var TrieRouter = class {
   name = "TrieRouter";
   #node;
@@ -2710,8 +3415,13 @@ var TrieRouter = class {
   }
 };
 
-// ../../node_modules/hono/dist/hono.js
+// ../../node_modules/.deno/hono@4.11.3/node_modules/hono/dist/hono.js
 var Hono2 = class extends Hono {
+  /**
+   * Creates an instance of the Hono class.
+   *
+   * @param options - Optional configuration options for the Hono instance.
+   */
   constructor(options = {}) {
     super(options);
     this.router = options.router ?? new SmartRouter({
@@ -2720,29 +3430,6 @@ var Hono2 = class extends Hono {
   }
 };
 
-// ../../node_modules/hono/dist/http-exception.js
-var HTTPException = class extends Error {
-  res;
-  status;
-  constructor(status = 500, options) {
-    super(options?.message, { cause: options?.cause });
-    this.res = options?.res;
-    this.status = status;
-  }
-  getResponse() {
-    if (this.res) {
-      const newResponse = new Response(this.res.body, {
-        status: this.status,
-        headers: this.res.headers
-      });
-      return newResponse;
-    }
-    return new Response(this.message, {
-      status: this.status
-    });
-  }
-};
-
 // src/server.ts
 async function handleError2(context, pluginOptions, error) {
   console.error(error);