@ubiquity-os/plugin-sdk 3.6.3 → 3.8.0

package/dist/index.js

@@ -41,7 +41,6 @@ module.exports = __toCommonJS(src_exports);
 
 // src/actions.ts
 var core = __toESM(require("@actions/core"));
-var github2 = __toESM(require("@actions/github"));
 var import_value3 = require("@sinclair/typebox/value");
 
 // ../../node_modules/@ubiquity-os/ubiquity-os-logger/dist/index.js
@@ -232,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;
@@ -379,10 +378,58 @@ var Logs = class _Logs {
 // src/actions.ts
 var import_dotenv = require("dotenv");
 
-// src/helpers/runtime-info.ts
-var import_github = __toESM(require("@actions/github"));
+// src/error.ts
+function getErrorStatus(err) {
+  if (!err || typeof err !== "object") return null;
+  const candidate = err;
+  const directStatus = candidate.status ?? candidate.response?.status;
+  if (typeof directStatus === "number" && Number.isFinite(directStatus)) return directStatus;
+  if (typeof directStatus === "string" && directStatus.trim()) {
+    const parsed = Number.parseInt(directStatus, 10);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  if (err instanceof Error) {
+    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;
+    }
+  }
+  return null;
+}
+function logByStatus(context, message, metadata) {
+  const status = getErrorStatus(metadata.err);
+  const payload = { ...metadata, ...status ? { status } : {} };
+  if (status && status >= 500) return context.logger.error(message, payload);
+  if (status && status >= 400) return context.logger.warn(message, payload);
+  if (status && status >= 300) return context.logger.debug(message, payload);
+  if (status && status >= 200) return context.logger.ok(message, payload);
+  if (status && status >= 100) return context.logger.info(message, payload);
+  return context.logger.error(message, payload);
+}
+function transformError(context, error) {
+  if (error instanceof LogReturn) {
+    return error;
+  }
+  if (error instanceof AggregateError) {
+    const message = error.errors.map((err) => {
+      if (err instanceof LogReturn) {
+        return err.logMessage.raw;
+      }
+      if (err instanceof Error) {
+        return err.message;
+      }
+      return String(err);
+    }).join("\n\n");
+    return logByStatus(context, message, { err: error });
+  }
+  if (error instanceof Error) {
+    return logByStatus(context, error.message, { err: 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;
@@ -395,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: () => ({})
   };
@@ -432,6 +480,21 @@ var checkUserAgentEquals = (platform) => {
   return userAgent.startsWith(platform);
 };
 
+// src/helpers/github-context.ts
+var github = __toESM(require("@actions/github"));
+function getGithubContext() {
+  const override = globalThis.__UOS_GITHUB_CONTEXT__;
+  if (override) {
+    return override;
+  }
+  const module2 = github;
+  const context = module2.context ?? module2.default?.context;
+  if (!context) {
+    throw new Error("GitHub context is unavailable.");
+  }
+  return context;
+}
+
 // src/helpers/runtime-info.ts
 var PluginRuntimeInfo = class _PluginRuntimeInfo {
   static _instance = null;
@@ -480,10 +543,11 @@ var CfRuntimeInfo = class extends PluginRuntimeInfo {
 };
 var NodeRuntimeInfo = class extends PluginRuntimeInfo {
   get version() {
-    return import_github.default.context.sha;
+    return getGithubContext().sha;
   }
   get runUrl() {
-    return import_github.default.context.payload.repository ? `${import_github.default.context.payload.repository?.html_url}/actions/runs/${import_github.default.context.runId}` : "http://localhost";
+    const context = getGithubContext();
+    return context.payload.repository ? `${context.payload.repository?.html_url}/actions/runs/${context.runId}` : "http://localhost";
   }
 };
 var DenoRuntimeInfo = class extends PluginRuntimeInfo {
@@ -573,14 +637,72 @@ 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);
+  if (status && status >= 400) return logger.warn(message, payload);
+  if (status && status >= 300) return logger.debug(message, payload);
+  if (status && status >= 200) return logger.ok(message, payload);
+  if (status && status >= 100) return logger.info(message, payload);
+  return logger.error(message, payload);
+}
 var CommentHandler = class _CommentHandler {
   static HEADER_NAME = "UbiquityOS";
   _lastCommentId = { reviewCommentId: null, issueCommentId: null };
-  async _updateIssueComment(context2, params) {
+  _commandResponsePolicyApplied = false;
+  async _updateIssueComment(context, params) {
     if (!this._lastCommentId.issueCommentId) {
-      throw context2.logger.error("issueCommentId is missing");
+      throw context.logger.error("issueCommentId is missing");
     }
-    const commentData = await context2.octokit.rest.issues.updateComment({
+    const commentData = await context.octokit.rest.issues.updateComment({
       owner: params.owner,
       repo: params.repo,
       comment_id: this._lastCommentId.issueCommentId,
@@ -588,11 +710,11 @@ var CommentHandler = class _CommentHandler {
     });
     return { ...commentData.data, issueNumber: params.issueNumber };
   }
-  async _updateReviewComment(context2, params) {
+  async _updateReviewComment(context, params) {
     if (!this._lastCommentId.reviewCommentId) {
-      throw context2.logger.error("reviewCommentId is missing");
+      throw context.logger.error("reviewCommentId is missing");
     }
-    const commentData = await context2.octokit.rest.pulls.updateReviewComment({
+    const commentData = await context.octokit.rest.pulls.updateReviewComment({
       owner: params.owner,
       repo: params.repo,
       comment_id: this._lastCommentId.reviewCommentId,
@@ -600,9 +722,9 @@ var CommentHandler = class _CommentHandler {
     });
     return { ...commentData.data, issueNumber: params.issueNumber };
   }
-  async _createNewComment(context2, params) {
+  async _createNewComment(context, params) {
     if (params.commentId) {
-      const commentData2 = await context2.octokit.rest.pulls.createReplyForReviewComment({
+      const commentData2 = await context.octokit.rest.pulls.createReplyForReviewComment({
         owner: params.owner,
         repo: params.repo,
         pull_number: params.issueNumber,
@@ -612,7 +734,7 @@ var CommentHandler = class _CommentHandler {
       this._lastCommentId.reviewCommentId = commentData2.data.id;
       return { ...commentData2.data, issueNumber: params.issueNumber };
     }
-    const commentData = await context2.octokit.rest.issues.createComment({
+    const commentData = await context.octokit.rest.issues.createComment({
       owner: params.owner,
       repo: params.repo,
       issue_number: params.issueNumber,
@@ -621,54 +743,143 @@ var CommentHandler = class _CommentHandler {
     this._lastCommentId.issueCommentId = commentData.data.id;
     return { ...commentData.data, issueNumber: params.issueNumber };
   }
-  _getIssueNumber(context2) {
-    if ("issue" in context2.payload) return context2.payload.issue.number;
-    if ("pull_request" in context2.payload) return context2.payload.pull_request.number;
-    if ("discussion" in context2.payload) return context2.payload.discussion.number;
+  _getIssueNumber(context) {
+    if ("issue" in context.payload) return context.payload.issue.number;
+    if ("pull_request" in context.payload) return context.payload.pull_request.number;
+    if ("discussion" in context.payload) return context.payload.discussion.number;
     return void 0;
   }
-  _getCommentId(context2) {
-    return "pull_request" in context2.payload && "comment" in context2.payload ? context2.payload.comment.id : void 0;
+  _getCommentId(context) {
+    return "pull_request" in context.payload && "comment" in context.payload ? context.payload.comment.id : void 0;
   }
-  _extractIssueContext(context2) {
-    if (!("repository" in context2.payload) || !context2.payload.repository?.owner?.login) {
+  _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;
     }
-    const issueNumber = this._getIssueNumber(context2);
+    const issueNumber = this._getIssueNumber(context);
     if (!issueNumber) return null;
     return {
       issueNumber,
-      commentId: this._getCommentId(context2),
-      owner: context2.payload.repository.owner.login,
-      repo: context2.payload.repository.name
+      commentId: this._getCommentId(context),
+      owner: context.payload.repository.owner.login,
+      repo: context.payload.repository.name
     };
   }
-  _processMessage(context2, message) {
+  _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 = {
         message: message.message,
         name: message.name,
         stack: message.stack
       };
-      return { metadata: metadata2, logMessage: context2.logger.error(message.message).logMessage };
+      const status = getErrorStatus(message);
+      const logReturn = logByStatus2(context.logger, message.message, status, metadata2);
+      return { metadata: { ...metadata2, ...status ? { status } : {} }, logMessage: logReturn.logMessage };
     }
+    const stackLine = message.metadata?.error?.stack?.split("\n")[2];
+    const callerMatch = stackLine ? /at (\S+)/.exec(stackLine) : null;
     const metadata = message.metadata ? {
       ...message.metadata,
       message: message.metadata.message,
       stack: message.metadata.stack || message.metadata.error?.stack,
-      caller: message.metadata.caller || message.metadata.error?.stack?.split("\n")[2]?.match(/at (\S+)/)?.[1]
+      caller: message.metadata.caller || callerMatch?.[1]
     } : { ...message };
     return { metadata, logMessage: message.logMessage };
   }
-  _getInstigatorName(context2) {
-    if ("installation" in context2.payload && context2.payload.installation && "account" in context2.payload.installation && context2.payload.installation?.account?.name) {
-      return context2.payload.installation?.account?.name;
+  _getInstigatorName(context) {
+    if ("installation" in context.payload && context.payload.installation && "account" in context.payload.installation && context.payload.installation?.account?.name) {
+      return context.payload.installation?.account?.name;
     }
-    return context2.payload.sender?.login || _CommentHandler.HEADER_NAME;
+    return context.payload.sender?.login || _CommentHandler.HEADER_NAME;
   }
-  _createMetadataContent(context2, metadata) {
+  _createMetadataContent(context, metadata) {
     const jsonPretty = sanitizeMetadata(metadata);
-    const instigatorName = this._getInstigatorName(context2);
+    const instigatorName = this._getInstigatorName(context);
     const runUrl = PluginRuntimeInfo.getInstance().runUrl;
     const version = PluginRuntimeInfo.getInstance().version;
     const callingFnName = metadata.caller || "anonymous";
@@ -685,63 +896,46 @@ var CommentHandler = class _CommentHandler {
   /*
    * Creates the body for the comment, embeds the metadata and the header hidden in the body as well.
    */
-  createCommentBody(context2, message, options) {
-    return this._createCommentBody(context2, message, options);
-  }
-  _createCommentBody(context2, message, options) {
-    const { metadata, logMessage } = this._processMessage(context2, message);
-    const { header, jsonPretty } = this._createMetadataContent(context2, metadata);
+  createCommentBody(context, message, options) {
+    return this._createCommentBody(context, message, options);
+  }
+  _createCommentBody(context, message, options) {
+    const { metadata, logMessage } = this._processMessage(context, message);
+    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}
 
 ${metadataContent}
 `;
   }
-  async postComment(context2, message, options = { updateComment: true, raw: false }) {
-    const issueContext = this._extractIssueContext(context2);
+  async postComment(context, message, options = { updateComment: true, raw: false }) {
+    await this._applyCommandResponsePolicy(context);
+    const issueContext = this._extractIssueContext(context);
     if (!issueContext) {
-      context2.logger.warn("Cannot post comment: missing issue context in payload");
+      context.logger.warn("Cannot post comment: missing issue context in payload");
       return null;
     }
-    const body = this._createCommentBody(context2, 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) {
-      if (this._lastCommentId.issueCommentId && !("pull_request" in context2.payload && "comment" in context2.payload)) {
-        return this._updateIssueComment(context2, params);
+      if (this._lastCommentId.issueCommentId && !("pull_request" in context.payload && "comment" in context.payload)) {
+        return this._updateIssueComment(context, params);
       }
-      if (this._lastCommentId.reviewCommentId && "pull_request" in context2.payload && "comment" in context2.payload) {
-        return this._updateReviewComment(context2, params);
+      if (this._lastCommentId.reviewCommentId && "pull_request" in context.payload && "comment" in context.payload) {
+        return this._updateReviewComment(context, params);
       }
     }
-    return this._createNewComment(context2, { ...params, commentId });
+    return this._createNewComment(context, { ...params, commentId });
   }
 };
 
-// src/error.ts
-function transformError(context2, error) {
-  let loggerError;
-  if (error instanceof AggregateError) {
-    loggerError = context2.logger.error(
-      error.errors.map((err) => {
-        if (err instanceof LogReturn) {
-          return err.logMessage.raw;
-        } else if (err instanceof Error) {
-          return err.message;
-        } else {
-          return err;
-        }
-      }).join("\n\n"),
-      { error }
-    );
-  } else if (error instanceof Error || error instanceof LogReturn) {
-    loggerError = error;
-  } else {
-    loggerError = context2.logger.error(String(error));
-  }
-  return loggerError;
-}
-
 // src/helpers/command.ts
 var import_value = require("@sinclair/typebox/value");
 function getCommand(inputs, pluginOptions) {
@@ -974,7 +1168,7 @@ async function verifySignature(publicKeyPem, inputs, signature) {
       ref: inputs.ref,
       command: inputs.command
     };
-    const pemContents = publicKeyPem.replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "").trim();
+    const pemContents = publicKeyPem.replace("-----BEGIN PUBLIC KEY-----", "").replace("-----END PUBLIC KEY-----", "").replace(/\s+/g, "");
     const binaryDer = Uint8Array.from(atob(pemContents), (c) => c.charCodeAt(0));
     const publicKey = await crypto.subtle.importKey(
       "spki",
@@ -1027,16 +1221,12 @@ var inputSchema = import_typebox3.Type.Object({
 
 // src/actions.ts
 (0, import_dotenv.config)();
-async function handleError(context2, pluginOptions, error) {
+async function handleError(context, pluginOptions, error) {
   console.error(error);
-  const loggerError = transformError(context2, error);
-  if (loggerError instanceof LogReturn) {
-    core.setFailed(loggerError.logMessage.diff);
-  } else if (loggerError instanceof Error) {
-    core.setFailed(loggerError);
-  }
+  const loggerError = transformError(context, error);
+  core.setFailed(loggerError.logMessage.diff);
   if (pluginOptions.postCommentOnError && loggerError) {
-    await context2.commentHandler.postComment(context2, loggerError);
+    await context.commentHandler.postComment(context, loggerError);
   }
 }
 async function createActionsPlugin(handler, options) {
@@ -1046,7 +1236,8 @@ async function createActionsPlugin(handler, options) {
     core.setFailed("Error: PLUGIN_GITHUB_TOKEN env is not set");
     return;
   }
-  const body = github2.context.payload.inputs;
+  const githubContext = getGithubContext();
+  const body = githubContext.payload.inputs;
   const inputSchemaErrors = [...import_value3.Value.Errors(inputSchema, body)];
   if (inputSchemaErrors.length) {
     console.dir(inputSchemaErrors, { depth: null });
@@ -1084,7 +1275,7 @@ async function createActionsPlugin(handler, options) {
     env2 = process.env;
   }
   const command = getCommand(inputs, pluginOptions);
-  const context2 = {
+  const context = {
     eventName: inputs.eventName,
     payload: inputs.eventPayload,
     command,
@@ -1097,20 +1288,21 @@ async function createActionsPlugin(handler, options) {
     commentHandler: new CommentHandler()
   };
   try {
-    const result = await handler(context2);
+    const result = await handler(context);
     core.setOutput("result", result);
     if (pluginOptions?.returnDataToKernel) {
       await returnDataToKernel(pluginGithubToken, inputs.stateId, result);
     }
   } catch (error) {
-    await handleError(context2, pluginOptions, error);
+    await handleError(context, pluginOptions, error);
   }
 }
 async function returnDataToKernel(repoToken, stateId, output) {
+  const githubContext = getGithubContext();
   const octokit = new customOctokit({ auth: repoToken });
   await octokit.rest.repos.createDispatchEvent({
-    owner: github2.context.repo.owner,
-    repo: github2.context.repo.repo,
+    owner: githubContext.repo.owner,
+    repo: githubContext.repo.repo,
     event_type: "return-data-to-ubiquity-os-kernel",
     client_payload: {
       state_id: stateId,
@@ -1127,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));
@@ -1175,9 +1367,9 @@ 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 (context2, next) => {
+  return (context, next) => {
     let index = -1;
     return dispatch(0);
     async function dispatch(i) {
@@ -1190,39 +1382,72 @@ var compose = (middleware, onError, onNotFound) => {
       let handler;
       if (middleware[i]) {
         handler = middleware[i][0][0];
-        context2.req.routeIndex = i;
+        context.req.routeIndex = i;
       } else {
         handler = i === middleware.length && next || void 0;
       }
       if (handler) {
         try {
-          res = await handler(context2, () => dispatch(i + 1));
+          res = await handler(context, () => dispatch(i + 1));
         } catch (err) {
           if (err instanceof Error && onError) {
-            context2.error = err;
-            res = await onError(err, context2);
+            context.error = err;
+            res = await onError(err, context);
             isError = true;
           } else {
             throw err;
           }
         }
       } else {
-        if (context2.finalized === false && onNotFound) {
-          res = await onNotFound(context2);
+        if (context.finalized === false && onNotFound) {
+          res = await onNotFound(context);
         }
       }
-      if (res && (context2.finalized === false || isError)) {
-        context2.res = res;
+      if (res && (context.finalized === false || isError)) {
+        context.res = res;
       }
-      return context2;
+      return context;
     }
   };
 };
 
-// ../../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;
@@ -1291,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] === "") {
@@ -1306,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 };
@@ -1330,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];
@@ -1348,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;
       }
     });
   }
@@ -1360,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);
@@ -1426,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);
@@ -1493,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 = [[]]) {
@@ -1514,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;
       }
     }
@@ -1566,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,
@@ -1616,7 +1998,7 @@ var raw = (value, callbacks) => {
   escapedString.callbacks = callbacks;
   return escapedString;
 };
-var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) => {
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
   if (typeof str === "object" && !(str instanceof String)) {
     if (!(str instanceof Promise)) {
       str = str.toString();
@@ -1634,9 +2016,9 @@ var resolveCallback = async (str, phase, preserveCallbacks, context2, buffer) =>
   } else {
     buffer = [str];
   }
-  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context: context2 }))).then(
+  const resStr = Promise.all(callbacks.map((c) => c({ phase, buffer, context }))).then(
     (res) => Promise.all(
-      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context2, buffer))
+      res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))
     ).then(() => buffer[0])
   );
   if (preserveCallbacks) {
@@ -1646,7 +2028,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context2, 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 {
@@ -1657,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;
@@ -1670,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) {
@@ -1680,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;
@@ -1691,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;
@@ -1698,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);
@@ -1724,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);
@@ -1749,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 {};
@@ -1790,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,
@@ -1798,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),
@@ -1809,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"];
@@ -1831,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);
 };
@@ -1846,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;
@@ -1856,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 = [];
@@ -1904,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
     });
@@ -1914,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) => {
@@ -1929,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;
@@ -2029,21 +2740,44 @@ var Hono = class {
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
     return (async () => {
       try {
-        const context2 = await composed(c);
-        if (!context2.finalized) {
+        const context = await composed(c);
+        if (!context.finalized) {
           throw new Error(
             "Context is not finalized. Did you forget to return a Response object or `await next()`?"
           );
         }
-        return context2.res;
+        return context.res;
       } catch (err) {
         return this.#handleError(err, c);
       }
     })();
   }
+  /**
+   * `.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);
@@ -2058,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));
@@ -2065,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) {
@@ -2090,11 +2862,11 @@ 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);
-  insert(tokens, index, paramMap, context2, pathErrorCheckOnly) {
+  insert(tokens, index, paramMap, context, pathErrorCheckOnly) {
     if (tokens.length === 0) {
       if (this.#index !== void 0) {
         throw PATH_ERROR;
@@ -2130,9 +2902,9 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.#children[regexpStr] = new Node();
+        node = this.#children[regexpStr] = new _Node();
         if (name !== "") {
-          node.#varIndex = context2.varIndex++;
+          node.#varIndex = context.varIndex++;
         }
       }
       if (!pathErrorCheckOnly && name !== "") {
@@ -2149,10 +2921,10 @@ var Node = class {
         if (pathErrorCheckOnly) {
           return;
         }
-        node = this.#children[token] = new Node();
+        node = this.#children[token] = new _Node();
       }
     }
-    node.insert(restTokens, index, paramMap, context2, pathErrorCheckOnly);
+    node.insert(restTokens, index, paramMap, context, pathErrorCheckOnly);
   }
   buildRegExpStr() {
     const childKeys = Object.keys(this.#children).sort(compareKey);
@@ -2173,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();
@@ -2229,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) {
@@ -2377,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) {
@@ -2425,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 = [];
@@ -2480,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;
@@ -2515,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]);
@@ -2638,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;
@@ -2660,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({
@@ -2670,35 +3430,12 @@ 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(context2, pluginOptions, error) {
+async function handleError2(context, pluginOptions, error) {
   console.error(error);
-  const loggerError = transformError(context2, error);
+  const loggerError = transformError(context, error);
   if (pluginOptions.postCommentOnError && loggerError) {
-    await context2.commentHandler.postComment(context2, loggerError);
+    await context.commentHandler.postComment(context, loggerError);
   }
   throw new HTTPException(500, { message: "Unexpected error" });
 }
@@ -2749,7 +3486,7 @@ function createPlugin(handler, manifest, options) {
     const workerName = new URL(inputs.ref).hostname.split(".")[0];
     PluginRuntimeInfo.getInstance({ ...env2, CLOUDFLARE_WORKER_NAME: workerName });
     const command = getCommand(inputs, pluginOptions);
-    const context2 = {
+    const context = {
       eventName: inputs.eventName,
       payload: inputs.eventPayload,
       command,
@@ -2762,10 +3499,10 @@ function createPlugin(handler, manifest, options) {
       commentHandler: new CommentHandler()
     };
     try {
-      const result = await handler(context2);
+      const result = await handler(context);
       return ctx.json({ stateId: inputs.stateId, output: result ?? {} });
     } catch (error) {
-      await handleError2(context2, pluginOptions, error);
+      await handleError2(context, pluginOptions, error);
     }
   });
   return app;
@@ -2780,6 +3517,14 @@ function normalizeBaseUrl(baseUrl) {
   }
   return normalized;
 }
+var MAX_LLM_RETRIES = 2;
+var RETRY_BACKOFF_MS = [250, 750];
+function getRetryDelayMs(attempt) {
+  return RETRY_BACKOFF_MS[Math.min(attempt, RETRY_BACKOFF_MS.length - 1)] ?? 750;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
 function getEnvString(name) {
   if (typeof process === "undefined" || !process?.env) return EMPTY_STRING;
   return String(process.env[name] ?? EMPTY_STRING).trim();
@@ -2794,7 +3539,11 @@ function getAiBaseUrl(options) {
 }
 async function callLlm(options, input) {
   const authToken = String(input.authToken ?? EMPTY_STRING).trim();
-  if (!authToken) throw new Error("Missing authToken in input");
+  if (!authToken) {
+    const err = new Error("Missing authToken in input");
+    err.status = 401;
+    throw err;
+  }
   const kernelToken = "ubiquityKernelToken" in input ? input.ubiquityKernelToken : void 0;
   const payload = getPayload(input);
   const { owner, repo, installationId } = getRepoMetadata(payload);
@@ -2814,13 +3563,7 @@ async function callLlm(options, input) {
     installationId,
     ubiquityKernelToken: kernelToken
   });
-  const response = await fetch(url, { method: "POST", headers, body });
-  if (!response.ok) {
-    const err = await response.text();
-    const error = new Error(`LLM API error: ${response.status} - ${err}`);
-    error.status = response.status;
-    throw error;
-  }
+  const response = await fetchWithRetry(url, { method: "POST", headers, body }, MAX_LLM_RETRIES);
   if (isStream) {
     if (!response.body) {
       throw new Error("LLM API error: missing response body for streaming request");
@@ -2832,17 +3575,46 @@ async function callLlm(options, input) {
 function ensureKernelToken(authToken, kernelToken) {
   const isKernelTokenRequired = authToken.startsWith("gh");
   if (isKernelTokenRequired && !kernelToken) {
-    throw new Error("Missing ubiquityKernelToken in input (kernel attestation is required for GitHub auth)");
+    const err = new Error("Missing ubiquityKernelToken in input (kernel attestation is required for GitHub auth)");
+    err.status = 401;
+    throw err;
   }
 }
 function ensureMessages(messages) {
   if (!Array.isArray(messages) || messages.length === 0) {
-    throw new Error("messages must be a non-empty array");
+    const err = new Error("messages must be a non-empty array");
+    err.status = 400;
+    throw err;
   }
 }
 function buildAiUrl(options, baseUrl) {
   return `${getAiBaseUrl({ ...options, baseUrl })}/v1/chat/completions`;
 }
+async function fetchWithRetry(url, options, maxRetries) {
+  let attempt = 0;
+  let lastError;
+  while (attempt <= maxRetries) {
+    try {
+      const response = await fetch(url, options);
+      if (response.ok) return response;
+      const errText = await response.text();
+      if (response.status >= 500 && attempt < maxRetries) {
+        await sleep(getRetryDelayMs(attempt));
+        attempt += 1;
+        continue;
+      }
+      const error = new Error(`LLM API error: ${response.status} - ${errText}`);
+      error.status = response.status;
+      throw error;
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries) throw error;
+      await sleep(getRetryDelayMs(attempt));
+      attempt += 1;
+    }
+  }
+  throw lastError ?? new Error("LLM API error: request failed after retries");
+}
 function getPayload(input) {
   if ("payload" in input) {
     return input.payload;
@@ -2904,7 +3676,7 @@ function getEventData(event) {
   if (!event.trim()) return null;
   const dataLines = event.split("\n").filter((line) => line.startsWith("data:"));
   if (!dataLines.length) return null;
-  const data = dataLines.map((line) => line.startsWith("data: ") ? line.slice(6) : line.slice(5).replace(/^ /, "")).join("\n");
+  const data = dataLines.map((line) => line.startsWith("data: ") ? line.slice(6) : line.slice(5).replace(/^ /, EMPTY_STRING)).join("\n");
   return data || null;
 }
 function parseEventData(data) {