@cyanheads/git-mcp-server 2.11.1 → 2.12.0

package/dist/index.js

@@ -15284,7 +15284,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@cyanheads/git-mcp-server",
-    version: "2.11.1",
+    version: "2.12.0",
     mcpName: "io.github.cyanheads/git-mcp-server",
     description: "A secure and scalable Git MCP server enabling AI agents to perform comprehensive Git version control operations via STDIO and Streamable HTTP.",
     main: "dist/index.js",
@@ -15343,10 +15343,10 @@ var init_package = __esm(() => {
       "publish-mcp": "bun scripts/validate-mcp-publish-schema.ts"
     },
     devDependencies: {
-      "@cloudflare/workers-types": "^4.20260418.1",
+      "@cloudflare/workers-types": "^4.20260423.1",
       "@eslint/js": "^10.0.1",
       "@hono/mcp": "^0.2.5",
-      "@hono/node-server": "^1.19.14",
+      "@hono/node-server": "^2.0.0",
       "@modelcontextprotocol/sdk": "^1.29.0",
       "@opentelemetry/api": "^1.9.1",
       "@opentelemetry/auto-instrumentations-node": "^0.73.0",
@@ -15358,13 +15358,13 @@ var init_package = __esm(() => {
       "@opentelemetry/sdk-node": "^0.215.0",
       "@opentelemetry/sdk-trace-node": "^2.7.0",
       "@opentelemetry/semantic-conventions": "^1.40.0",
-      "@supabase/supabase-js": "^2.103.3",
-      "@types/bun": "^1.3.12",
+      "@supabase/supabase-js": "^2.104.1",
+      "@types/bun": "^1.3.13",
       "@types/cross-spawn": "^6.0.6",
       "@types/node": "^25.6.0",
       "@types/validator": "^13.15.10",
-      "@vitest/coverage-v8": "^4.1.4",
-      "bun-types": "^1.3.12",
+      "@vitest/coverage-v8": "^4.1.5",
+      "bun-types": "^1.3.13",
       depcheck: "^1.4.7",
       dotenv: "^17.4.2",
       eslint: "^10.2.1",
@@ -15374,7 +15374,7 @@ var init_package = __esm(() => {
       husky: "^9.1.7",
       ignore: "^7.0.5",
       jose: "^6.2.2",
-      msw: "^2.13.4",
+      msw: "^2.13.5",
       prettier: "^3.8.3",
       "reflect-metadata": "^0.2.2",
       repomix: "^1.13.1",
@@ -15382,11 +15382,11 @@ var init_package = __esm(() => {
       tsyringe: "^4.10.0",
       typedoc: "^0.28.19",
       typescript: "^6.0.3",
-      "typescript-eslint": "^8.58.2",
+      "typescript-eslint": "^8.59.0",
       validator: "^13.15.35",
-      vite: "^8.0.8",
+      vite: "^8.0.10",
       "vite-tsconfig-paths": "^6.1.1",
-      vitest: "^4.1.4",
+      vitest: "^4.1.5",
       zod: "^4.3.6"
     },
     keywords: [
@@ -60779,7 +60779,7 @@ var require_root = __commonJS((exports, module) => {
               return values;
             }();
             Span.Event = function() {
-              function Event(properties) {
+              function Event2(properties) {
                 this.attributes = [];
                 if (properties) {
                   for (var keys = Object.keys(properties), i2 = 0;i2 < keys.length; ++i2)
@@ -60787,14 +60787,14 @@ var require_root = __commonJS((exports, module) => {
                       this[keys[i2]] = properties[keys[i2]];
                 }
               }
-              Event.prototype.timeUnixNano = null;
-              Event.prototype.name = null;
-              Event.prototype.attributes = $util.emptyArray;
-              Event.prototype.droppedAttributesCount = null;
-              Event.create = function create(properties) {
-                return new Event(properties);
+              Event2.prototype.timeUnixNano = null;
+              Event2.prototype.name = null;
+              Event2.prototype.attributes = $util.emptyArray;
+              Event2.prototype.droppedAttributesCount = null;
+              Event2.create = function create(properties) {
+                return new Event2(properties);
               };
-              Event.encode = function encode3(message, writer) {
+              Event2.encode = function encode3(message, writer) {
                 if (!writer)
                   writer = $Writer.create();
                 if (message.timeUnixNano != null && Object.hasOwnProperty.call(message, "timeUnixNano"))
@@ -60808,10 +60808,10 @@ var require_root = __commonJS((exports, module) => {
                   writer.uint32(32).uint32(message.droppedAttributesCount);
                 return writer;
               };
-              Event.encodeDelimited = function encodeDelimited(message, writer) {
+              Event2.encodeDelimited = function encodeDelimited(message, writer) {
                 return this.encode(message, writer).ldelim();
               };
-              Event.decode = function decode3(reader, length, error48) {
+              Event2.decode = function decode3(reader, length, error48) {
                 if (!(reader instanceof $Reader))
                   reader = $Reader.create(reader);
                 var end = length === undefined ? reader.len : reader.pos + length, message = new $root.opentelemetry.proto.trace.v1.Span.Event;
@@ -60845,12 +60845,12 @@ var require_root = __commonJS((exports, module) => {
                 }
                 return message;
               };
-              Event.decodeDelimited = function decodeDelimited(reader) {
+              Event2.decodeDelimited = function decodeDelimited(reader) {
                 if (!(reader instanceof $Reader))
                   reader = new $Reader(reader);
                 return this.decode(reader, reader.uint32());
               };
-              Event.verify = function verify(message) {
+              Event2.verify = function verify(message) {
                 if (typeof message !== "object" || message === null)
                   return "object expected";
                 if (message.timeUnixNano != null && message.hasOwnProperty("timeUnixNano")) {
@@ -60876,7 +60876,7 @@ var require_root = __commonJS((exports, module) => {
                 }
                 return null;
               };
-              Event.fromObject = function fromObject(object2) {
+              Event2.fromObject = function fromObject(object2) {
                 if (object2 instanceof $root.opentelemetry.proto.trace.v1.Span.Event)
                   return object2;
                 var message = new $root.opentelemetry.proto.trace.v1.Span.Event;
@@ -60906,7 +60906,7 @@ var require_root = __commonJS((exports, module) => {
                   message.droppedAttributesCount = object2.droppedAttributesCount >>> 0;
                 return message;
               };
-              Event.toObject = function toObject(message, options) {
+              Event2.toObject = function toObject(message, options) {
                 if (!options)
                   options = {};
                 var object2 = {};
@@ -60937,16 +60937,16 @@ var require_root = __commonJS((exports, module) => {
                   object2.droppedAttributesCount = message.droppedAttributesCount;
                 return object2;
               };
-              Event.prototype.toJSON = function toJSON() {
+              Event2.prototype.toJSON = function toJSON() {
                 return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
               };
-              Event.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+              Event2.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
                 if (typeUrlPrefix === undefined) {
                   typeUrlPrefix = "type.googleapis.com";
                 }
                 return typeUrlPrefix + "/opentelemetry.proto.trace.v1.Span.Event";
               };
-              return Event;
+              return Event2;
             }();
             Span.Link = function() {
               function Link(properties) {
@@ -105608,7 +105608,8 @@ var init_requestContext = __esm(() => {
       }
       const authStore = authContext.getStore();
       const tenantIdFromAuth = authStore?.authInfo?.tenantId;
-      const requestId = typeof inheritedContext.requestId === "string" && inheritedContext.requestId ? inheritedContext.requestId : generateRequestContextId();
+      const inheritedRequestId = inheritedContext.requestId;
+      const requestId = typeof inheritedRequestId === "string" && inheritedRequestId ? inheritedRequestId : generateRequestContextId();
       const timestamp = new Date().toISOString();
       const restTenantId = typeof rest.tenantId === "string" ? rest.tenantId : undefined;
       const additionalTenantId = additionalContext && typeof additionalContext === "object" && typeof additionalContext.tenantId === "string" ? additionalContext.tenantId : undefined;
@@ -115934,7 +115935,7 @@ Suggested solution: ${env.workaround}`;
 var require_version48 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.version = undefined;
-  exports.version = "2.103.3";
+  exports.version = "2.104.1";
 });
 
 // node_modules/@supabase/realtime-js/dist/main/lib/constants.js
@@ -118798,7 +118799,7 @@ var require_main3 = __commonJS((exports) => {
 var require_version49 = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.version = undefined;
-  exports.version = "2.103.3";
+  exports.version = "2.104.1";
 });
 
 // node_modules/@supabase/auth-js/dist/main/lib/constants.js
@@ -119380,7 +119381,7 @@ var require_helpers2 = __commonJS((exports) => {
     const codeVerifier = generatePKCEVerifier();
     let storedCodeVerifier = codeVerifier;
     if (isPasswordRecovery) {
-      storedCodeVerifier += "/PASSWORD_RECOVERY";
+      storedCodeVerifier += "/recovery";
     }
     await (0, exports.setItemAsync)(storage, `${storageKey}-code-verifier`, storedCodeVerifier);
     const codeChallenge = await generatePKCEChallenge(codeVerifier);
@@ -121615,7 +121616,7 @@ var require_GoTrueClient = __commonJS((exports) => {
         }
         if (data.session) {
           await this._saveSession(data.session);
-          await this._notifyAllSubscribers("SIGNED_IN", data.session);
+          await this._notifyAllSubscribers(redirectType === "recovery" ? "PASSWORD_RECOVERY" : "SIGNED_IN", data.session);
         }
         return this._returnResult({ data: Object.assign(Object.assign({}, data), { redirectType: redirectType !== null && redirectType !== undefined ? redirectType : null }), error: error48 });
       } catch (error48) {
@@ -122130,6 +122131,7 @@ var require_GoTrueClient = __commonJS((exports) => {
       }
     }
     async _getSessionFromURL(params, callbackUrlType) {
+      var _a2;
       try {
         if (!(0, helpers_1.isBrowser)())
           throw new errors_1.AuthImplicitGrantRedirectError("No browser detected.");
@@ -122162,7 +122164,10 @@ var require_GoTrueClient = __commonJS((exports) => {
           const url2 = new URL(window.location.href);
           url2.searchParams.delete("code");
           window.history.replaceState(window.history.state, "", url2.toString());
-          return { data: { session: data2.session, redirectType: null }, error: null };
+          return {
+            data: { session: data2.session, redirectType: (_a2 = data2.redirectType) !== null && _a2 !== undefined ? _a2 : null },
+            error: null
+          };
         }
         const { provider_token, provider_refresh_token, access_token, refresh_token, expires_in, expires_at, token_type } = params;
         if (!access_token || !expires_in || !refresh_token || !token_type) {
@@ -131567,6 +131572,21 @@ var StorageVectorsErrorCode = /* @__PURE__ */ function(StorageVectorsErrorCode$1
   StorageVectorsErrorCode$1["S3VectorMaxIndexesExceeded"] = "S3VectorMaxIndexesExceeded";
   return StorageVectorsErrorCode$1;
 }({});
+function setHeader(headers, name, value) {
+  const result = _objectSpread22({}, headers);
+  const nameLower = name.toLowerCase();
+  for (const key of Object.keys(result))
+    if (key.toLowerCase() === nameLower)
+      delete result[key];
+  result[nameLower] = value;
+  return result;
+}
+function normalizeHeaders(headers) {
+  const result = {};
+  for (const [key, value] of Object.entries(headers))
+    result[key.toLowerCase()] = value;
+  return result;
+}
 var resolveFetch = (customFetch) => {
   if (customFetch)
     return (...args) => customFetch(...args);
@@ -131635,7 +131655,7 @@ var _getRequestParams = (method, options, parameters, body) => {
     for (const [key, value] of Object.entries(headers))
       if (key.toLowerCase() === "content-type")
         contentType = value;
-    params.headers = setRequestHeader(headers, "Content-Type", (_contentType = contentType) !== null && _contentType !== undefined ? _contentType : "application/json");
+    params.headers = setHeader(headers, "Content-Type", (_contentType = contentType) !== null && _contentType !== undefined ? _contentType : "application/json");
     params.body = JSON.stringify(body);
   } else
     params.body = body;
@@ -131643,14 +131663,6 @@ var _getRequestParams = (method, options, parameters, body) => {
     params.duplex = options.duplex;
   return _objectSpread22(_objectSpread22({}, params), parameters);
 };
-function setRequestHeader(headers, name, value) {
-  const nextHeaders = _objectSpread22({}, headers);
-  for (const key of Object.keys(nextHeaders))
-    if (key.toLowerCase() === name.toLowerCase())
-      delete nextHeaders[key];
-  nextHeaders[name] = value;
-  return nextHeaders;
-}
 async function _handleRequest(fetcher, method, url2, options, parameters, body, namespace) {
   return new Promise((resolve, reject) => {
     fetcher(url2, _getRequestParams(method, options, parameters, body)).then((result) => {
@@ -131695,7 +131707,7 @@ var BaseApiClient = class {
   constructor(url2, headers = {}, fetch$1, namespace = "storage") {
     this.shouldThrowOnError = false;
     this.url = url2;
-    this.headers = Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
+    this.headers = normalizeHeaders(headers);
     this.fetch = resolveFetch(fetch$1);
     this.namespace = namespace;
   }
@@ -131704,7 +131716,7 @@ var BaseApiClient = class {
     return this;
   }
   setHeader(name, value) {
-    this.headers = _objectSpread22(_objectSpread22({}, this.headers), {}, { [name.toLowerCase()]: value });
+    this.headers = setHeader(this.headers, name, value);
     return this;
   }
   async handleOperation(operation) {
@@ -131845,7 +131857,8 @@ var StorageFileApi = class extends BaseApiClient {
           options.duplex = "half";
       }
       if (fileOptions === null || fileOptions === undefined ? undefined : fileOptions.headers)
-        headers = _objectSpread22(_objectSpread22({}, headers), fileOptions.headers);
+        for (const [key, value] of Object.entries(fileOptions.headers))
+          headers = setHeader(headers, key, value);
       const cleanPath = _this._removeEmptyFolders(path2);
       const _path = _this._getFinalPath(cleanPath);
       const data = await (method == "PUT" ? put : post)(_this.fetch, `${_this.url}/object/${_path}`, body, _objectSpread22({ headers }, (options === null || options === undefined ? undefined : options.duplex) ? { duplex: options.duplex } : {}));
@@ -132069,7 +132082,7 @@ var StorageFileApi = class extends BaseApiClient {
     return query;
   }
 };
-var version2 = "2.103.3";
+var version2 = "2.104.1";
 var DEFAULT_HEADERS = { "X-Client-Info": `storage-js/${version2}` };
 var StorageBucketApi = class extends BaseApiClient {
   constructor(url2, headers = {}, fetch$1, opts) {
@@ -132452,7 +132465,7 @@ var StorageClient = class extends StorageBucketApi {
 var import_auth_js = __toESM(require_main4(), 1);
 __reExport(exports_dist3, __toESM(require_main3(), 1));
 __reExport(exports_dist3, __toESM(require_main4(), 1));
-var version3 = "2.103.3";
+var version3 = "2.104.1";
 var JS_ENV = "";
 if (typeof Deno !== "undefined")
   JS_ENV = "deno";
@@ -132620,7 +132633,8 @@ var SupabaseClient = class {
     this.fetch = fetchWithAuth(supabaseKey, this._getAccessToken.bind(this), settings.global.fetch);
     this.realtime = this._initRealtimeClient(_objectSpread23({
       headers: this.headers,
-      accessToken: this._getAccessToken.bind(this)
+      accessToken: this._getAccessToken.bind(this),
+      fetch: this.fetch
     }, settings.realtime));
     if (this.accessToken)
       Promise.resolve(this.accessToken()).then((token) => this.realtime.setAuth(token)).catch((e2) => console.warn("Failed to set initial Realtime auth token:", e2));
@@ -146537,11 +146551,10 @@ import path4 from "path";
 init_config();
 var TOOL_NAME10 = "git_wrapup_instructions";
 var TOOL_TITLE10 = "Git Wrap-up Instructions";
-var TOOL_DESCRIPTION10 = "Provides the user's desired Git wrap-up workflow and instructions. Returns custom workflow steps (if configured) or default best practices for reviewing, documenting, and committing changes. Includes current repository status to guide next actions.";
+var TOOL_DESCRIPTION10 = "Returns a Git wrap-up protocol: an acceptance-criteria checklist the agent must satisfy before the session is considered shipped. Uses the operator's custom instructions if configured, otherwise emits a generic goals-strict/mechanism-generic default. Includes current repository status to guide next actions.";
 var InputSchema10 = exports_external.object({
   acknowledgement: exports_external.enum(["Y", "y", "Yes", "yes"]).describe("Acknowledgement to initiate the wrap-up workflow."),
-  updateAgentMetaFiles: exports_external.enum(["Y", "y", "Yes", "yes"]).optional().describe("Include an instruction to update agent-specific meta files."),
-  createTag: exports_external.boolean().optional().describe("If true, instructs the agent to create a Git tag after committing all changes. Only set to true if given permission to do so.")
+  createTag: exports_external.boolean().optional().describe("Controls whether the tag criterion appears in the emitted protocol. Omit or set `true` to include the tag step. Set `false` to omit it entirely — e.g., when tagging is deferred to a separate release step.")
 });
 var OutputSchema11 = exports_external.object({
   instructions: exports_external.string().describe("The set of instructions for the wrap-up workflow."),
@@ -146553,71 +146566,73 @@ var OutputSchema11 = exports_external.object({
   }).optional().describe("The current structured git status."),
   gitStatusError: exports_external.string().optional().describe("Any error message if getting git status failed.")
 });
-var DEFAULT_WRAPUP_INSTRUCTIONS = `
-# Git Wrap-up Protocol
+function buildDefaultInstructions(input) {
+  const tagCriterion = input.createTag === false ? "" : "\n- [ ] Annotated tag at the project's convention (typically `v<version>`) with a concise message summarizing the real changes — no filler. Flag if a tag already exists at this commit.";
+  return `# Git Wrap-up
+
+**Outcome**: a new release — version bumped, changes documented and verified, committed atomically, and tagged.
+
+**Philosophy**: strict on goals, generic on mechanism. The acceptance checkboxes are fixed; everything beneath them is guidance that defers to project convention.
 
-**Objective**: Systematically review, document, and commit all pending changes in the repository. Adherence to this protocol is mandatory.
+## Orient
 
-### Phase 1: Analysis and Planning
+Before touching git, read the project. Check the root agent-instruction file (\`AGENTS.md\`, \`CLAUDE.md\`, or equivalent) for wrap-up expectations, version locations, and any bespoke checklist. Identify:
 
-You must begin by creating a task list that mirrors this protocol. This is your operational plan.
+- how changes are recorded (flat changelog, directory-based, release-notes tooling, or none)
+- where versions are declared (manifest, server descriptor, \`VERSION\` file, tag-driven, or embedded in docs)
+- what verification looks like (the project's check-suite, which may be a single combined command or several run in sequence)
+- what mirrors version or structure (badges, generated docs, agent-instruction files, templated files)
 
-**Example Task List:**
-\`\`\`
-- [ ] Set Git working directory (if not set)
-- [ ] Analyze repository changes with git_diff
-- [ ] Update CHANGELOG.md with all modifications
-- [ ] Review and update README.md for currency
-- [ ] Commit changes in logical, atomic units
-- [ ] Verify final repository status
-\`\`\`
+If the project documents its own wrap-up procedure, follow it — the checklist below is the baseline, not an override.
 
-### Phase 2: Execution Workflow
+## Acceptance criteria
 
-Execute the following steps sequentially. Do not proceed until the prior step is confirmed complete.
+A wrap-up is complete when every checkbox is satisfied. Every wrap-up is a release: minimum patch bump unless the change warrants minor or major.
 
-1.  **Set Context**: Ensure the working directory is correctly set using **\`git_set_working_dir\`**. This is a mandatory first step.
+- [ ] Full diff reviewed end-to-end before commits are planned
+- [ ] Version bumped per semver (default patch; minor/major when warranted) across every place the project declares it — manifest, server descriptor, badges, agent-instruction files, templated mirrors
+- [ ] Changelog updated under the new version in the project's existing format, or created conventionally if none exists
+- [ ] Documentation that references changed behaviour is current
+- [ ] Verification suite passes against the tree being committed
+- [ ] Commits are atomic and in Conventional Commits form${tagCriterion}
 
-2.  **Analyze Changes**: Execute **\`git_diff\`** with the \`includeUntracked: true\` parameter. You must thoroughly analyze the output to understand the full scope and rationale of every modification. This analysis will inform & influence your commit strategy, commit messages, and overall workflow.
+**Commonly relevant files** (check these if present; exact names vary by project):
 
-3.  **Update Changelog**: Read the **\`CHANGELOG.md\`** file. Append a new version entry detailing all changes. Your entry must be concise, use the past tense, and categorize modifications (e.g., "Added," "Changed," "Fixed").
+- **Documentation**: \`README.md\`, generated structure docs like \`docs/tree.md\`, and any usage or reference docs affected by the change.
+- **Agent-instruction files**: \`AGENTS.md\`, \`CLAUDE.md\`, or equivalents — if the code changes alter anything these files describe (architecture, available tools, conventions, file layout), update them to match. If they are symlinked or mirrored, edit the source; the link or mirror reflects automatically.
+- **Version sources**: manifests (\`package.json\`, \`pyproject.toml\`, \`Cargo.toml\`), server descriptors (\`server.json\`), \`VERSION\` files — bump in lockstep.
 
-4.  **Review Documentation**: For any substantial code changes, you are required to review **\`README.md\`**. Ensure it accurately reflects the current state of the codebase. Update it as necessary.
+**Style defaults** (overridable by project convention):
 
-5.  **Commit Changes**: Execute **\`git_commit\`** for each logical group of changes.
-    - Commits **must be atomic** and group related changes.
-    - Commit messages **must adhere** to the **Conventional Commits** standard (e.g., \`feat(auth): implement password reset\`).
-    - Use the \`filesToStage\` parameter to precisely control which files are included in each commit.
+- Cross-reference issues and PRs with full URLs — \`[#42](https://github.com/owner/repo/pull/42)\` or \`owner/repo#42\`. Bare \`#42\` breaks outside the GitHub web UI.
+- Commit and changelog entries lead with specifics — name the tool, service, or module affected in the first few words.
 
-**Directive**: Create your task list now. Then, execute the protocol. Do not push to the remote unless explicitly instructed.
+## Constraints
+
+- Do not push to the remote unless explicitly instructed.
+- Do not bypass verification failures to land a green commit.
+- Do not rewrite published history.
 `;
-function loadInstructions(filePath) {
+}
+function loadCustomInstructions(filePath) {
   if (!filePath) {
-    logger.debug("No custom instructions path configured, using default.");
-    return DEFAULT_WRAPUP_INSTRUCTIONS;
+    logger.debug("No custom wrap-up instructions configured; using built-in default.");
+    return null;
   }
   try {
     const resolvedPath = path4.resolve(filePath);
-    logger.debug(`Loading custom instructions from ${resolvedPath} at module initialization`);
+    logger.debug(`Loading custom wrap-up instructions from ${resolvedPath} at module initialization.`);
     return readFileSync(resolvedPath, "utf-8");
   } catch (error48) {
     const errorMessage = error48 instanceof Error ? error48.message : "An unknown error occurred";
-    logger.warning(`Failed to load custom instructions from '${filePath}': ${errorMessage}. Falling back to default instructions.`);
-    return DEFAULT_WRAPUP_INSTRUCTIONS;
+    logger.warning(`Failed to load custom wrap-up instructions from '${filePath}': ${errorMessage}. Falling back to built-in default.`);
+    return null;
   }
 }
-var baseInstructions = loadInstructions(config2?.git?.wrapupInstructionsPath);
+var customInstructions = loadCustomInstructions(config2?.git?.wrapupInstructionsPath);
 async function gitWrapupInstructionsLogic(input, { provider, storage, appContext }) {
   const tenantId = appContext.tenantId || "default-tenant";
-  let finalInstructions = baseInstructions;
-  if (input.updateAgentMetaFiles) {
-    finalInstructions += `
-Extra request: review and update if needed the .cline_rules and claude.md files if present.`;
-  }
-  if (input.createTag) {
-    finalInstructions += `
-6. After all changes are committed and confirmed via 'git_status', use the 'git_tag' tool to create a new annotated tag. The tag name should follow semantic versioning (e.g., v1.2.3), and the annotation message should summarize the key changes in this wrap-up.`;
-  }
+  const finalInstructions = customInstructions ?? buildDefaultInstructions(input);
   let gitStatus;
   let gitStatusError;
   try {
@@ -151098,44 +151113,115 @@ var RingBuffer = class {
   }
 };
 
+// node_modules/@hono/node-server/dist/constants-BLSFu_RU.mjs
+var X_ALREADY_SENT = "x-hono-already-sent";
+
+// node_modules/@hono/node-server/dist/index.mjs
+import { STATUS_CODES, createServer } from "node:http";
+import { Http2ServerRequest, constants } from "node:http2";
+import { Readable } from "node:stream";
+
+// node_modules/hono/dist/helper/websocket/index.js
+var WSContext = class {
+  #init;
+  constructor(init) {
+    this.#init = init;
+    this.raw = init.raw;
+    this.url = init.url ? new URL(init.url) : null;
+    this.protocol = init.protocol ?? null;
+  }
+  send(source, options) {
+    this.#init.send(source, options ?? {});
+  }
+  raw;
+  binaryType = "arraybuffer";
+  get readyState() {
+    return this.#init.readyState;
+  }
+  url;
+  protocol;
+  close(code, reason) {
+    this.#init.close(code, reason);
+  }
+};
+var defineWebSocketHelper = (handler) => {
+  return (...args) => {
+    if (typeof args[0] === "function") {
+      const [createEvents, options] = args;
+      return async function upgradeWebSocket(c, next) {
+        const events = await createEvents(c);
+        const result = await handler(c, events, options);
+        if (result) {
+          return result;
+        }
+        await next();
+      };
+    } else {
+      const [c, events, options] = args;
+      return (async () => {
+        const upgraded = await handler(c, events, options);
+        if (!upgraded) {
+          throw new Error("Failed to upgrade WebSocket");
+        }
+        return upgraded;
+      })();
+    }
+  };
+};
+
 // node_modules/@hono/node-server/dist/index.mjs
-import { createServer as createServerHTTP } from "http";
-import { Http2ServerRequest as Http2ServerRequest2, constants as h2constants } from "http2";
-import { Http2ServerRequest } from "http2";
-import { Readable } from "stream";
-import crypto3 from "crypto";
 var RequestError = class extends Error {
   constructor(message, options) {
     super(message, options);
     this.name = "RequestError";
   }
 };
+var reValidRequestUrl = /^\/[!#$&-;=?-\[\]_a-z~]*$/;
+var reDotSegment = /\/\.\.?(?:[/?#]|$)/;
+var reValidHost = /^[a-z0-9._-]+(?::(?:[1-5]\d{3,4}|[6-9]\d{3}))?$/;
+var buildUrl2 = (scheme, host, incomingUrl) => {
+  const url2 = `${scheme}://${host}${incomingUrl}`;
+  if (!reValidHost.test(host)) {
+    const urlObj = new URL(url2);
+    if (urlObj.hostname.length !== host.length && urlObj.hostname !== (host.includes(":") ? host.replace(/:\d+$/, "") : host).toLowerCase())
+      throw new RequestError("Invalid host header");
+    return urlObj.href;
+  } else if (incomingUrl.length === 0)
+    return url2 + "/";
+  else {
+    if (incomingUrl.charCodeAt(0) !== 47)
+      throw new RequestError("Invalid URL");
+    if (!reValidRequestUrl.test(incomingUrl) || reDotSegment.test(incomingUrl))
+      return new URL(url2).href;
+    return url2;
+  }
+};
 var toRequestError = (e2) => {
-  if (e2 instanceof RequestError) {
+  if (e2 instanceof RequestError)
     return e2;
-  }
   return new RequestError(e2.message, { cause: e2 });
 };
 var GlobalRequest = global.Request;
-var Request3 = class extends GlobalRequest {
+var Request$1 = class extends GlobalRequest {
   constructor(input, options) {
     if (typeof input === "object" && getRequestCache in input) {
+      const hasReplacementBody = options !== undefined && "body" in options && options.body != null;
+      if (input[bodyConsumedDirectlyKey] && !hasReplacementBody)
+        throw new TypeError("Cannot construct a Request with a Request object that has already been used.");
       input = input[getRequestCache]();
     }
-    if (typeof options?.body?.getReader !== "undefined") {
+    if (typeof options?.body?.getReader !== "undefined")
       options.duplex ??= "half";
-    }
     super(input, options);
   }
 };
 var newHeadersFromIncoming = (incoming) => {
   const headerRecord = [];
   const rawHeaders = incoming.rawHeaders;
-  for (let i2 = 0;i2 < rawHeaders.length; i2 += 2) {
-    const { [i2]: key, [i2 + 1]: value } = rawHeaders;
-    if (key.charCodeAt(0) !== 58) {
-      headerRecord.push([key, value]);
-    }
+  for (let i2 = 0, len = rawHeaders.length;i2 < len; i2 += 2) {
+    const key = rawHeaders[i2];
+    if (key.charCodeAt(0) !== 58)
+      headerRecord.push([key, rawHeaders[i2 + 1]]);
   }
   return new Headers(headerRecord);
 };
@@ -151148,55 +151234,213 @@ var newRequestFromIncoming = (method, url2, headers, incoming, abortController)
   };
   if (method === "TRACE") {
     init.method = "GET";
-    const req = new Request3(url2, init);
-    Object.defineProperty(req, "method", {
-      get() {
-        return "TRACE";
-      }
-    });
+    const req = new Request$1(url2, init);
+    Object.defineProperty(req, "method", { get() {
+      return "TRACE";
+    } });
     return req;
   }
-  if (!(method === "GET" || method === "HEAD")) {
-    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
-      init.body = new ReadableStream({
-        start(controller) {
-          controller.enqueue(incoming.rawBody);
-          controller.close();
-        }
-      });
-    } else if (incoming[wrapBodyStream]) {
+  if (!(method === "GET" || method === "HEAD"))
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer)
+      init.body = new ReadableStream({ start(controller) {
+        controller.enqueue(incoming.rawBody);
+        controller.close();
+      } });
+    else if (incoming[wrapBodyStream]) {
       let reader;
-      init.body = new ReadableStream({
-        async pull(controller) {
-          try {
-            reader ||= Readable.toWeb(incoming).getReader();
-            const { done, value } = await reader.read();
-            if (done) {
-              controller.close();
-            } else {
-              controller.enqueue(value);
-            }
-          } catch (error48) {
-            controller.error(error48);
-          }
+      init.body = new ReadableStream({ async pull(controller) {
+        try {
+          reader ||= Readable.toWeb(incoming).getReader();
+          const { done, value } = await reader.read();
+          if (done)
+            controller.close();
+          else
+            controller.enqueue(value);
+        } catch (error48) {
+          controller.error(error48);
         }
-      });
-    } else {
+      } });
+    } else
       init.body = Readable.toWeb(incoming);
-    }
-  }
-  return new Request3(url2, init);
+  return new Request$1(url2, init);
 };
 var getRequestCache = Symbol("getRequestCache");
 var requestCache = Symbol("requestCache");
 var incomingKey = Symbol("incomingKey");
 var urlKey = Symbol("urlKey");
+var methodKey = Symbol("methodKey");
 var headersKey = Symbol("headersKey");
 var abortControllerKey = Symbol("abortControllerKey");
 var getAbortController = Symbol("getAbortController");
+var abortRequest = Symbol("abortRequest");
+var bodyBufferKey = Symbol("bodyBuffer");
+var bodyReadPromiseKey = Symbol("bodyReadPromise");
+var bodyConsumedDirectlyKey = Symbol("bodyConsumedDirectly");
+var bodyLockReaderKey = Symbol("bodyLockReader");
+var abortReasonKey = Symbol("abortReason");
+var newBodyUnusableError = () => {
+  return /* @__PURE__ */ new TypeError("Body is unusable");
+};
+var rejectBodyUnusable = () => {
+  return Promise.reject(newBodyUnusableError());
+};
+var textDecoder = new TextDecoder;
+var consumeBodyDirectOnce = (request) => {
+  if (request[bodyConsumedDirectlyKey])
+    return rejectBodyUnusable();
+  request[bodyConsumedDirectlyKey] = true;
+};
+var toArrayBuffer = (buf) => {
+  return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+};
+var contentType = (request) => {
+  return (request[headersKey] ||= newHeadersFromIncoming(request[incomingKey])).get("content-type") || "";
+};
+var methodTokenRegExp = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
+var normalizeIncomingMethod = (method) => {
+  if (typeof method !== "string" || method.length === 0)
+    return "GET";
+  switch (method) {
+    case "DELETE":
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+    case "POST":
+    case "PUT":
+      return method;
+  }
+  const upper = method.toUpperCase();
+  switch (upper) {
+    case "DELETE":
+    case "GET":
+    case "HEAD":
+    case "OPTIONS":
+    case "POST":
+    case "PUT":
+      return upper;
+    default:
+      return method;
+  }
+};
+var validateDirectReadMethod = (method) => {
+  if (!methodTokenRegExp.test(method))
+    return /* @__PURE__ */ new TypeError(`'${method}' is not a valid HTTP method.`);
+  const normalized = method.toUpperCase();
+  if (normalized === "CONNECT" || normalized === "TRACK" || normalized === "TRACE" && method !== "TRACE")
+    return /* @__PURE__ */ new TypeError(`'${method}' HTTP method is unsupported.`);
+};
+var readBodyWithFastPath = (request, method, fromBuffer) => {
+  if (request[bodyConsumedDirectlyKey])
+    return rejectBodyUnusable();
+  const methodName = request.method;
+  if (methodName === "GET" || methodName === "HEAD")
+    return request[getRequestCache]()[method]();
+  const methodValidationError = validateDirectReadMethod(methodName);
+  if (methodValidationError)
+    return Promise.reject(methodValidationError);
+  if (request[requestCache]) {
+    if (methodName !== "TRACE")
+      return request[requestCache][method]();
+  }
+  const alreadyUsedError = consumeBodyDirectOnce(request);
+  if (alreadyUsedError)
+    return alreadyUsedError;
+  const raw2 = readRawBodyIfAvailable(request);
+  if (raw2) {
+    const result = Promise.resolve(fromBuffer(raw2, request));
+    request[bodyBufferKey] = undefined;
+    return result;
+  }
+  return readBodyDirect(request).then((buf) => {
+    const result = fromBuffer(buf, request);
+    request[bodyBufferKey] = undefined;
+    return result;
+  });
+};
+var readRawBodyIfAvailable = (request) => {
+  const incoming = request[incomingKey];
+  if ("rawBody" in incoming && incoming.rawBody instanceof Buffer)
+    return incoming.rawBody;
+};
+var readBodyDirect = (request) => {
+  if (request[bodyBufferKey])
+    return Promise.resolve(request[bodyBufferKey]);
+  if (request[bodyReadPromiseKey])
+    return request[bodyReadPromiseKey];
+  const incoming = request[incomingKey];
+  if (Readable.isDisturbed(incoming))
+    return rejectBodyUnusable();
+  const promise3 = new Promise((resolve2, reject) => {
+    const chunks = [];
+    let settled = false;
+    const finish = (callback) => {
+      if (settled)
+        return;
+      settled = true;
+      cleanup();
+      callback();
+    };
+    const onData = (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    };
+    const onEnd = () => {
+      finish(() => {
+        const buffer = chunks.length === 1 ? chunks[0] : Buffer.concat(chunks);
+        request[bodyBufferKey] = buffer;
+        resolve2(buffer);
+      });
+    };
+    const onError = (error48) => {
+      finish(() => {
+        reject(error48);
+      });
+    };
+    const onClose = () => {
+      if (incoming.readableEnded) {
+        onEnd();
+        return;
+      }
+      finish(() => {
+        if (incoming.errored) {
+          reject(incoming.errored);
+          return;
+        }
+        const reason = request[abortReasonKey];
+        if (reason !== undefined) {
+          reject(reason instanceof Error ? reason : new Error(String(reason)));
+          return;
+        }
+        reject(/* @__PURE__ */ new Error("Client connection prematurely closed."));
+      });
+    };
+    const cleanup = () => {
+      incoming.off("data", onData);
+      incoming.off("end", onEnd);
+      incoming.off("error", onError);
+      incoming.off("close", onClose);
+      request[bodyReadPromiseKey] = undefined;
+    };
+    incoming.on("data", onData);
+    incoming.on("end", onEnd);
+    incoming.on("error", onError);
+    incoming.on("close", onClose);
+    queueMicrotask(() => {
+      if (settled)
+        return;
+      if (incoming.readableEnded)
+        onEnd();
+      else if (incoming.errored)
+        onError(incoming.errored);
+      else if (incoming.destroyed)
+        onClose();
+    });
+  });
+  request[bodyReadPromiseKey] = promise3;
+  return promise3;
+};
 var requestPrototype = {
   get method() {
-    return this[incomingKey].method || "GET";
+    return this[methodKey];
   },
   get url() {
     return this[urlKey];
@@ -151204,18 +151448,66 @@ var requestPrototype = {
   get headers() {
     return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
   },
+  [abortRequest](reason) {
+    if (this[abortReasonKey] === undefined)
+      this[abortReasonKey] = reason;
+    const abortController = this[abortControllerKey];
+    if (abortController && !abortController.signal.aborted)
+      abortController.abort(reason);
+  },
   [getAbortController]() {
-    this[getRequestCache]();
+    this[abortControllerKey] ||= new AbortController;
+    if (this[abortReasonKey] !== undefined && !this[abortControllerKey].signal.aborted)
+      this[abortControllerKey].abort(this[abortReasonKey]);
     return this[abortControllerKey];
   },
   [getRequestCache]() {
-    this[abortControllerKey] ||= new AbortController;
-    return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
+    const abortController = this[getAbortController]();
+    if (this[requestCache])
+      return this[requestCache];
+    const method = this.method;
+    if (this[bodyConsumedDirectlyKey] && !(method === "GET" || method === "HEAD")) {
+      this[bodyBufferKey] = undefined;
+      const init = {
+        method: method === "TRACE" ? "GET" : method,
+        headers: this.headers,
+        signal: abortController.signal
+      };
+      if (method !== "TRACE") {
+        init.body = new ReadableStream({ start(c) {
+          c.close();
+        } });
+        init.duplex = "half";
+      }
+      const req = new Request$1(this[urlKey], init);
+      if (method === "TRACE")
+        Object.defineProperty(req, "method", { get() {
+          return "TRACE";
+        } });
+      return this[requestCache] = req;
+    }
+    return this[requestCache] = newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], abortController);
+  },
+  get body() {
+    if (!this[bodyConsumedDirectlyKey])
+      return this[getRequestCache]().body;
+    const request = this[getRequestCache]();
+    if (!this[bodyLockReaderKey] && request.body)
+      this[bodyLockReaderKey] = request.body.getReader();
+    return request.body;
+  },
+  get bodyUsed() {
+    if (this[bodyConsumedDirectlyKey])
+      return true;
+    if (this[requestCache])
+      return this[requestCache].bodyUsed;
+    return false;
   }
 };
+Object.defineProperty(requestPrototype, "signal", { get() {
+  return this[getAbortController]().signal;
+} });
 [
-  "body",
-  "bodyUsed",
   "cache",
   "credentials",
   "destination",
@@ -151224,75 +151516,93 @@ var requestPrototype = {
   "redirect",
   "referrer",
   "referrerPolicy",
-  "signal",
   "keepalive"
 ].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    get() {
-      return this[getRequestCache]()[k];
-    }
-  });
-});
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(requestPrototype, k, {
-    value: function() {
-      return this[getRequestCache]()[k]();
-    }
-  });
-});
-Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), {
-  value: function(depth, options, inspectFn) {
-    const props = {
-      method: this.method,
-      url: this.url,
-      headers: this.headers,
-      nativeRequest: this[requestCache]
-    };
-    return `Request (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
-  }
-});
-Object.setPrototypeOf(requestPrototype, Request3.prototype);
+  Object.defineProperty(requestPrototype, k, { get() {
+    return this[getRequestCache]()[k];
+  } });
+});
+["clone", "formData"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, { value: function() {
+    if (this[bodyConsumedDirectlyKey]) {
+      if (k === "clone")
+        throw newBodyUnusableError();
+      return rejectBodyUnusable();
+    }
+    return this[getRequestCache]()[k]();
+  } });
+});
+Object.defineProperty(requestPrototype, "text", { value: function() {
+  return readBodyWithFastPath(this, "text", (buf) => textDecoder.decode(buf));
+} });
+Object.defineProperty(requestPrototype, "arrayBuffer", { value: function() {
+  return readBodyWithFastPath(this, "arrayBuffer", (buf) => toArrayBuffer(buf));
+} });
+Object.defineProperty(requestPrototype, "blob", { value: function() {
+  return readBodyWithFastPath(this, "blob", (buf, request) => {
+    const type = contentType(request);
+    const init = type ? { headers: { "content-type": type } } : undefined;
+    return new Response(buf, init).blob();
+  });
+} });
+Object.defineProperty(requestPrototype, "json", { value: function() {
+  if (this[bodyConsumedDirectlyKey])
+    return rejectBodyUnusable();
+  return this.text().then(JSON.parse);
+} });
+Object.defineProperty(requestPrototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+  return `Request (lightweight) ${inspectFn({
+    method: this.method,
+    url: this.url,
+    headers: this.headers,
+    nativeRequest: this[requestCache]
+  }, {
+    ...options,
+    depth: depth == null ? null : depth - 1
+  })}`;
+} });
+Object.setPrototypeOf(requestPrototype, Request$1.prototype);
 var newRequest = (incoming, defaultHostname) => {
   const req = Object.create(requestPrototype);
   req[incomingKey] = incoming;
+  req[methodKey] = normalizeIncomingMethod(incoming.method);
   const incomingUrl = incoming.url || "";
   if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
-    if (incoming instanceof Http2ServerRequest) {
+    if (incoming instanceof Http2ServerRequest)
       throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
-    }
     try {
-      const url22 = new URL(incomingUrl);
-      req[urlKey] = url22.href;
+      req[urlKey] = new URL(incomingUrl).href;
     } catch (e2) {
       throw new RequestError("Invalid absolute URL", { cause: e2 });
     }
     return req;
   }
   const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
-  if (!host) {
+  if (!host)
     throw new RequestError("Missing host header");
-  }
   let scheme;
   if (incoming instanceof Http2ServerRequest) {
     scheme = incoming.scheme;
-    if (!(scheme === "http" || scheme === "https")) {
+    if (!(scheme === "http" || scheme === "https"))
       throw new RequestError("Unsupported scheme");
-    }
-  } else {
+  } else
     scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  try {
+    req[urlKey] = buildUrl2(scheme, host, incomingUrl);
+  } catch (e2) {
+    if (e2 instanceof RequestError)
+      throw e2;
+    else
+      throw new RequestError("Invalid URL", { cause: e2 });
   }
-  const url2 = new URL(`${scheme}://${host}${incomingUrl}`);
-  if (url2.hostname.length !== host.length && url2.hostname !== host.replace(/:\d+$/, "")) {
-    throw new RequestError("Invalid host header");
-  }
-  req[urlKey] = url2.href;
   return req;
 };
+var defaultContentType = "text/plain; charset=UTF-8";
 var responseCache = Symbol("responseCache");
 var getResponseCache = Symbol("getResponseCache");
 var cacheKey = Symbol("cache");
 var GlobalResponse = global.Response;
-var Response22 = class _Response {
+var Response$1 = class Response$12 {
   #body;
   #init;
   [getResponseCache]() {
@@ -151302,7 +151612,7 @@ var Response22 = class _Response {
   constructor(body, init) {
     let headers;
     this.#body = body;
-    if (init instanceof _Response) {
+    if (init instanceof Response$12) {
       const cachedGlobalResponse = init[responseCache];
       if (cachedGlobalResponse) {
         this.#init = cachedGlobalResponse;
@@ -151312,19 +151622,20 @@ var Response22 = class _Response {
         this.#init = init.#init;
         headers = new Headers(init.#init.headers);
       }
-    } else {
+    } else
       this.#init = init;
-    }
-    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
-      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
-    }
+    if (body == null || typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array)
+      this[cacheKey] = [
+        init?.status || 200,
+        body ?? null,
+        headers || init?.headers
+      ];
   }
   get headers() {
     const cache = this[cacheKey];
     if (cache) {
-      if (!(cache[2] instanceof Headers)) {
-        cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
-      }
+      if (!(cache[2] instanceof Headers))
+        cache[2] = new Headers(cache[2] || (cache[1] === null ? undefined : { "content-type": defaultContentType }));
       return cache[2];
     }
     return this[getResponseCache]().headers;
@@ -151337,33 +151648,93 @@ var Response22 = class _Response {
     return status >= 200 && status < 300;
   }
 };
-["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
-  Object.defineProperty(Response22.prototype, k, {
-    get() {
-      return this[getResponseCache]()[k];
-    }
-  });
+[
+  "body",
+  "bodyUsed",
+  "redirected",
+  "statusText",
+  "trailers",
+  "type",
+  "url"
+].forEach((k) => {
+  Object.defineProperty(Response$1.prototype, k, { get() {
+    return this[getResponseCache]()[k];
+  } });
 });
-["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
-  Object.defineProperty(Response22.prototype, k, {
-    value: function() {
-      return this[getResponseCache]()[k]();
-    }
-  });
+[
+  "arrayBuffer",
+  "blob",
+  "clone",
+  "formData",
+  "json",
+  "text"
+].forEach((k) => {
+  Object.defineProperty(Response$1.prototype, k, { value: function() {
+    return this[getResponseCache]()[k]();
+  } });
 });
-Object.defineProperty(Response22.prototype, Symbol.for("nodejs.util.inspect.custom"), {
-  value: function(depth, options, inspectFn) {
-    const props = {
-      status: this.status,
-      headers: this.headers,
-      ok: this.ok,
-      nativeResponse: this[responseCache]
-    };
-    return `Response (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`;
-  }
+Object.defineProperty(Response$1.prototype, Symbol.for("nodejs.util.inspect.custom"), { value: function(depth, options, inspectFn) {
+  return `Response (lightweight) ${inspectFn({
+    status: this.status,
+    headers: this.headers,
+    ok: this.ok,
+    nativeResponse: this[responseCache]
+  }, {
+    ...options,
+    depth: depth == null ? null : depth - 1
+  })}`;
+} });
+Object.setPrototypeOf(Response$1, GlobalResponse);
+Object.setPrototypeOf(Response$1.prototype, GlobalResponse.prototype);
+var validRedirectUrl = /^https?:\/\/[!#-;=?-[\]_a-z~A-Z]+$/;
+var parseRedirectUrl = (url2) => {
+  if (url2 instanceof URL)
+    return url2.href;
+  if (validRedirectUrl.test(url2))
+    return url2;
+  return new URL(url2).href;
+};
+var validRedirectStatuses = new Set([
+  301,
+  302,
+  303,
+  307,
+  308
+]);
+Object.defineProperty(Response$1, "redirect", {
+  value: function redirect(url2, status = 302) {
+    if (!validRedirectStatuses.has(status))
+      throw new RangeError("Invalid status code");
+    return new Response$1(null, {
+      status,
+      headers: { location: parseRedirectUrl(url2) }
+    });
+  },
+  writable: true,
+  configurable: true
+});
+Object.defineProperty(Response$1, "json", {
+  value: function json2(data, init) {
+    const body = JSON.stringify(data);
+    if (body === undefined)
+      throw new TypeError("The data is not JSON serializable");
+    const initHeaders = init?.headers;
+    let headers;
+    if (initHeaders) {
+      headers = new Headers(initHeaders);
+      if (!headers.has("content-type"))
+        headers.set("content-type", "application/json");
+    } else
+      headers = { "content-type": "application/json" };
+    return new Response$1(body, {
+      status: init?.status ?? 200,
+      statusText: init?.statusText,
+      headers
+    });
+  },
+  writable: true,
+  configurable: true
 });
-Object.setPrototypeOf(Response22, GlobalResponse);
-Object.setPrototypeOf(Response22.prototype, GlobalResponse.prototype);
 async function readWithoutBlocking(readPromise) {
   return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
 }
@@ -151379,71 +151750,64 @@ function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromi
     writable.off("error", cancel);
   });
   function handleStreamError(error48) {
-    if (error48) {
+    if (error48)
       writable.destroy(error48);
-    }
   }
   function onDrain() {
     reader.read().then(flow, handleStreamError);
   }
   function flow({ done, value }) {
     try {
-      if (done) {
+      if (done)
         writable.end();
-      } else if (!writable.write(value)) {
+      else if (!writable.write(value))
         writable.once("drain", onDrain);
-      } else {
+      else
         return reader.read().then(flow, handleStreamError);
-      }
     } catch (e2) {
       handleStreamError(e2);
     }
   }
 }
 function writeFromReadableStream(stream2, writable) {
-  if (stream2.locked) {
+  if (stream2.locked)
     throw new TypeError("ReadableStream is locked.");
-  } else if (writable.destroyed) {
+  else if (writable.destroyed)
     return;
-  }
   return writeFromReadableStreamDefaultReader(stream2.getReader(), writable);
 }
-var buildOutgoingHttpHeaders = (headers) => {
+var buildOutgoingHttpHeaders = (headers, defaultContentType2) => {
   const res = {};
-  if (!(headers instanceof Headers)) {
+  if (!(headers instanceof Headers))
     headers = new Headers(headers ?? undefined);
-  }
-  const cookies = [];
-  for (const [k, v] of headers) {
-    if (k === "set-cookie") {
-      cookies.push(v);
-    } else {
+  if (headers.has("set-cookie")) {
+    const cookies = [];
+    for (const [k, v] of headers)
+      if (k === "set-cookie")
+        cookies.push(v);
+      else
+        res[k] = v;
+    if (cookies.length > 0)
+      res["set-cookie"] = cookies;
+  } else
+    for (const [k, v] of headers)
       res[k] = v;
-    }
-  }
-  if (cookies.length > 0) {
-    res["set-cookie"] = cookies;
-  }
-  res["content-type"] ??= "text/plain; charset=UTF-8";
+  if (defaultContentType2)
+    res["content-type"] ??= defaultContentType2;
   return res;
 };
-var X_ALREADY_SENT = "x-hono-already-sent";
-if (typeof global.crypto === "undefined") {
-  global.crypto = crypto3;
-}
 var outgoingEnded = Symbol("outgoingEnded");
 var incomingDraining = Symbol("incomingDraining");
 var DRAIN_TIMEOUT_MS = 500;
 var MAX_DRAIN_BYTES = 64 * 1024 * 1024;
 var drainIncoming = (incoming) => {
   const incomingWithDrainState = incoming;
-  if (incoming.destroyed || incomingWithDrainState[incomingDraining]) {
+  if (incoming.destroyed || incomingWithDrainState[incomingDraining])
     return;
-  }
   incomingWithDrainState[incomingDraining] = true;
-  if (incoming instanceof Http2ServerRequest2) {
+  if (incoming instanceof Http2ServerRequest) {
     try {
-      incoming.stream?.close?.(h2constants.NGHTTP2_NO_ERROR);
+      incoming.stream?.close?.(constants.NGHTTP2_NO_ERROR);
     } catch {}
     return;
   }
@@ -151457,82 +151821,120 @@ var drainIncoming = (incoming) => {
   const forceClose = () => {
     cleanup();
     const socket = incoming.socket;
-    if (socket && !socket.destroyed) {
+    if (socket && !socket.destroyed)
       socket.destroySoon();
-    }
   };
   const timer = setTimeout(forceClose, DRAIN_TIMEOUT_MS);
   timer.unref?.();
   const onData = (chunk) => {
     bytesRead += chunk.length;
-    if (bytesRead > MAX_DRAIN_BYTES) {
+    if (bytesRead > MAX_DRAIN_BYTES)
       forceClose();
-    }
   };
   incoming.on("data", onData);
   incoming.on("end", cleanup);
   incoming.on("error", cleanup);
   incoming.resume();
 };
-var handleRequestError = () => new Response(null, {
-  status: 400
-});
-var handleFetchError = (e2) => new Response(null, {
-  status: e2 instanceof Error && (e2.name === "TimeoutError" || e2.constructor.name === "TimeoutError") ? 504 : 500
-});
+var makeCloseHandler = (req, incoming, outgoing, needsBodyCleanup) => () => {
+  if (incoming.errored)
+    req[abortRequest](incoming.errored.toString());
+  else if (!outgoing.writableFinished)
+    req[abortRequest]("Client connection prematurely closed.");
+  if (needsBodyCleanup && !incoming.readableEnded)
+    setTimeout(() => {
+      if (!incoming.readableEnded)
+        setTimeout(() => {
+          drainIncoming(incoming);
+        });
+    });
+};
+var isImmediateCacheableResponse = (res) => {
+  if (!(cacheKey in res))
+    return false;
+  const body = res[cacheKey][1];
+  return body === null || typeof body === "string" || body instanceof Uint8Array;
+};
+var handleRequestError = () => new Response(null, { status: 400 });
+var handleFetchError = (e2) => new Response(null, { status: e2 instanceof Error && (e2.name === "TimeoutError" || e2.constructor.name === "TimeoutError") ? 504 : 500 });
 var handleResponseError = (e2, outgoing) => {
   const err = e2 instanceof Error ? e2 : new Error("unknown error", { cause: e2 });
-  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE")
     console.info("The user aborted a request.");
-  } else {
+  else {
     console.error(e2);
-    if (!outgoing.headersSent) {
+    if (!outgoing.headersSent)
       outgoing.writeHead(500, { "Content-Type": "text/plain" });
-    }
     outgoing.end(`Error: ${err.message}`);
     outgoing.destroy(err);
   }
 };
 var flushHeaders = (outgoing) => {
-  if ("flushHeaders" in outgoing && outgoing.writable) {
+  if ("flushHeaders" in outgoing && outgoing.writable)
     outgoing.flushHeaders();
-  }
 };
 var responseViaCache = async (res, outgoing) => {
   let [status, body, header] = res[cacheKey];
-  let hasContentLength = false;
   if (!header) {
-    header = { "content-type": "text/plain; charset=UTF-8" };
-  } else if (header instanceof Headers) {
+    if (body === null) {
+      outgoing.writeHead(status);
+      outgoing.end();
+    } else if (typeof body === "string") {
+      outgoing.writeHead(status, {
+        "Content-Type": defaultContentType,
+        "Content-Length": Buffer.byteLength(body)
+      });
+      outgoing.end(body);
+    } else if (body instanceof Uint8Array) {
+      outgoing.writeHead(status, {
+        "Content-Type": defaultContentType,
+        "Content-Length": body.byteLength
+      });
+      outgoing.end(body);
+    } else if (body instanceof Blob) {
+      outgoing.writeHead(status, {
+        "Content-Type": defaultContentType,
+        "Content-Length": body.size
+      });
+      outgoing.end(new Uint8Array(await body.arrayBuffer()));
+    } else {
+      outgoing.writeHead(status, { "Content-Type": defaultContentType });
+      flushHeaders(outgoing);
+      await writeFromReadableStream(body, outgoing)?.catch((e2) => handleResponseError(e2, outgoing));
+    }
+    outgoing[outgoingEnded]?.();
+    return;
+  }
+  let hasContentLength = false;
+  if (header instanceof Headers) {
     hasContentLength = header.has("content-length");
-    header = buildOutgoingHttpHeaders(header);
+    header = buildOutgoingHttpHeaders(header, body === null ? undefined : defaultContentType);
   } else if (Array.isArray(header)) {
     const headerObj = new Headers(header);
     hasContentLength = headerObj.has("content-length");
-    header = buildOutgoingHttpHeaders(headerObj);
-  } else {
-    for (const key in header) {
+    header = buildOutgoingHttpHeaders(headerObj, body === null ? undefined : defaultContentType);
+  } else
+    for (const key in header)
       if (key.length === 14 && key.toLowerCase() === "content-length") {
         hasContentLength = true;
         break;
       }
-    }
-  }
   if (!hasContentLength) {
-    if (typeof body === "string") {
+    if (typeof body === "string")
       header["Content-Length"] = Buffer.byteLength(body);
-    } else if (body instanceof Uint8Array) {
+    else if (body instanceof Uint8Array)
       header["Content-Length"] = body.byteLength;
-    } else if (body instanceof Blob) {
+    else if (body instanceof Blob)
       header["Content-Length"] = body.size;
-    }
   }
   outgoing.writeHead(status, header);
-  if (typeof body === "string" || body instanceof Uint8Array) {
+  if (body == null)
+    outgoing.end();
+  else if (typeof body === "string" || body instanceof Uint8Array)
     outgoing.end(body);
-  } else if (body instanceof Blob) {
+  else if (body instanceof Blob)
     outgoing.end(new Uint8Array(await body.arrayBuffer()));
-  } else {
+  else {
     flushHeaders(outgoing);
     await writeFromReadableStream(body, outgoing)?.catch((e2) => handleResponseError(e2, outgoing));
   }
@@ -151540,25 +151942,21 @@ var responseViaCache = async (res, outgoing) => {
 };
 var isPromise = (res) => typeof res.then === "function";
 var responseViaResponseObject = async (res, outgoing, options = {}) => {
-  if (isPromise(res)) {
-    if (options.errorHandler) {
+  if (isPromise(res))
+    if (options.errorHandler)
       try {
         res = await res;
       } catch (err) {
         const errRes = await options.errorHandler(err);
-        if (!errRes) {
+        if (!errRes)
           return;
-        }
         res = errRes;
       }
-    } else {
+    else
       res = await res.catch(handleFetchError);
-    }
-  }
-  if (cacheKey in res) {
+  if (cacheKey in res)
     return responseViaCache(res, outgoing);
-  }
-  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers, res.body === null ? undefined : defaultContentType);
   if (res.body) {
     const reader = res.body.getReader();
     const values = [];
@@ -151581,28 +151979,25 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
           break;
         }
         currentReadPromise = undefined;
-        if (chunk.value) {
+        if (chunk.value)
           values.push(chunk.value);
-        }
         if (chunk.done) {
           done = true;
           break;
         }
       }
-      if (done && !("content-length" in resHeaderRecord)) {
+      if (done && !("content-length" in resHeaderRecord))
         resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
-      }
     }
     outgoing.writeHead(res.status, resHeaderRecord);
     values.forEach((value) => {
       outgoing.write(value);
     });
-    if (done) {
+    if (done)
       outgoing.end();
-    } else {
-      if (values.length === 0) {
+    else {
+      if (values.length === 0)
         flushHeaders(outgoing);
-      }
       await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
     }
   } else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
@@ -151613,81 +152008,63 @@ var responseViaResponseObject = async (res, outgoing, options = {}) => {
 };
 var getRequestListener = (fetchCallback, options = {}) => {
   const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
-  if (options.overrideGlobalObjects !== false && global.Request !== Request3) {
-    Object.defineProperty(global, "Request", {
-      value: Request3
-    });
-    Object.defineProperty(global, "Response", {
-      value: Response22
-    });
+  if (options.overrideGlobalObjects !== false && global.Request !== Request$1) {
+    Object.defineProperty(global, "Request", { value: Request$1 });
+    Object.defineProperty(global, "Response", { value: Response$1 });
   }
   return async (incoming, outgoing) => {
     let res, req;
+    let needsBodyCleanup = false;
+    let closeHandlerAttached = false;
+    const ensureCloseHandler = () => {
+      if (!req || closeHandlerAttached)
+        return;
+      closeHandlerAttached = true;
+      outgoing.on("close", makeCloseHandler(req, incoming, outgoing, needsBodyCleanup));
+    };
     try {
       req = newRequest(incoming, options.hostname);
-      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
-      if (!incomingEnded) {
+      needsBodyCleanup = autoCleanupIncoming && !(incoming.method === "GET" || incoming.method === "HEAD");
+      if (needsBodyCleanup) {
         incoming[wrapBodyStream] = true;
-        incoming.on("end", () => {
-          incomingEnded = true;
-        });
-        if (incoming instanceof Http2ServerRequest2) {
+        if (incoming instanceof Http2ServerRequest)
           outgoing[outgoingEnded] = () => {
-            if (!incomingEnded) {
+            if (!incoming.readableEnded)
               setTimeout(() => {
-                if (!incomingEnded) {
+                if (!incoming.readableEnded)
                   setTimeout(() => {
-                    drainIncoming(incoming);
+                    incoming.destroy();
+                    outgoing.destroy();
                   });
-                }
               });
-            }
           };
-        }
-        outgoing.on("finish", () => {
-          if (!incomingEnded) {
-            drainIncoming(incoming);
-          }
-        });
       }
-      outgoing.on("close", () => {
-        const abortController = req[abortControllerKey];
-        if (abortController) {
-          if (incoming.errored) {
-            req[abortControllerKey].abort(incoming.errored.toString());
-          } else if (!outgoing.writableFinished) {
-            req[abortControllerKey].abort("Client connection prematurely closed.");
-          }
-        }
-        if (!incomingEnded) {
-          setTimeout(() => {
-            if (!incomingEnded) {
-              setTimeout(() => {
-                drainIncoming(incoming);
-              });
-            }
-          });
-        }
+      res = fetchCallback(req, {
+        incoming,
+        outgoing
       });
-      res = fetchCallback(req, { incoming, outgoing });
-      if (cacheKey in res) {
+      if (!isPromise(res) && isImmediateCacheableResponse(res)) {
+        if (needsBodyCleanup && !incoming.readableEnded)
+          outgoing.once("finish", () => {
+            if (!incoming.readableEnded)
+              drainIncoming(incoming);
+          });
         return responseViaCache(res, outgoing);
       }
+      ensureCloseHandler();
     } catch (e2) {
-      if (!res) {
+      if (!res)
         if (options.errorHandler) {
+          ensureCloseHandler();
           res = await options.errorHandler(req ? e2 : toRequestError(e2));
-          if (!res) {
+          if (!res)
             return;
-          }
-        } else if (!req) {
+        } else if (!req)
           res = handleRequestError();
-        } else {
+        else
           res = handleFetchError(e2);
-        }
-      } else {
+      else
         return handleResponseError(e2, outgoing);
-      }
     }
     try {
       return await responseViaResponseObject(res, outgoing, options);
@@ -151696,6 +152073,167 @@ var getRequestListener = (fetchCallback, options = {}) => {
     }
   };
 };
+var CloseEvent2 = globalThis.CloseEvent ?? class extends Event {
+  #eventInitDict;
+  constructor(type, eventInitDict = {}) {
+    super(type, eventInitDict);
+    this.#eventInitDict = eventInitDict;
+  }
+  get wasClean() {
+    return this.#eventInitDict.wasClean ?? false;
+  }
+  get code() {
+    return this.#eventInitDict.code ?? 0;
+  }
+  get reason() {
+    return this.#eventInitDict.reason ?? "";
+  }
+};
+var generateConnectionSymbol = () => Symbol("connection");
+var CONNECTION_SYMBOL_KEY = Symbol("CONNECTION_SYMBOL_KEY");
+var WAIT_FOR_WEBSOCKET_SYMBOL = Symbol("WAIT_FOR_WEBSOCKET_SYMBOL");
+var rejectUpgradeRequest = (socket, status) => {
+  socket.end(`HTTP/1.1 ${status.toString()} ${STATUS_CODES[status] ?? ""}\r
+Connection: close\r
+Content-Length: 0\r
+\r
+`);
+};
+var createUpgradeRequest = (request) => {
+  const protocol = request.socket.encrypted ? "https" : "http";
+  const url2 = new URL(request.url ?? "/", `${protocol}://${request.headers.host ?? "localhost"}`);
+  const headers = new Headers;
+  for (const key in request.headers) {
+    const value = request.headers[key];
+    if (!value)
+      continue;
+    headers.append(key, Array.isArray(value) ? value[0] : value);
+  }
+  return new Request(url2, { headers });
+};
+var setupWebSocket = (options) => {
+  const { server, fetchCallback, wss } = options;
+  const waiterMap = /* @__PURE__ */ new Map;
+  wss.on("connection", (ws, request) => {
+    const waiter = waiterMap.get(request);
+    if (waiter) {
+      waiter.resolve(ws);
+      waiterMap.delete(request);
+    }
+  });
+  const waitForWebSocket = (request, connectionSymbol) => {
+    return new Promise((resolve2) => {
+      waiterMap.set(request, {
+        resolve: resolve2,
+        connectionSymbol
+      });
+    });
+  };
+  server.on("upgrade", async (request, socket, head2) => {
+    if (request.headers.upgrade?.toLowerCase() !== "websocket")
+      return;
+    const env = {
+      incoming: request,
+      outgoing: undefined,
+      wss,
+      [WAIT_FOR_WEBSOCKET_SYMBOL]: waitForWebSocket
+    };
+    let status = 400;
+    try {
+      const response = await fetchCallback(createUpgradeRequest(request), env);
+      if (response instanceof Response)
+        status = response.status;
+    } catch {
+      if (server.listenerCount("upgrade") === 1)
+        rejectUpgradeRequest(socket, 500);
+      return;
+    }
+    const waiter = waiterMap.get(request);
+    if (!waiter || waiter.connectionSymbol !== env[CONNECTION_SYMBOL_KEY]) {
+      waiterMap.delete(request);
+      if (server.listenerCount("upgrade") === 1)
+        rejectUpgradeRequest(socket, status);
+      return;
+    }
+    wss.handleUpgrade(request, socket, head2, (ws) => {
+      wss.emit("connection", ws, request);
+    });
+  });
+  server.on("close", () => {
+    wss.close();
+  });
+};
+var upgradeWebSocket = defineWebSocketHelper(async (c, events, options) => {
+  if (c.req.header("upgrade")?.toLowerCase() !== "websocket")
+    return;
+  const env = c.env;
+  const waitForWebSocket = env[WAIT_FOR_WEBSOCKET_SYMBOL];
+  if (!waitForWebSocket || !env.incoming)
+    return new Response(null, { status: 500 });
+  const connectionSymbol = generateConnectionSymbol();
+  env[CONNECTION_SYMBOL_KEY] = connectionSymbol;
+  (async () => {
+    const ws = await waitForWebSocket(env.incoming, connectionSymbol);
+    const messagesReceivedInStarting = [];
+    const bufferMessage = (data, isBinary) => {
+      messagesReceivedInStarting.push([data, isBinary]);
+    };
+    ws.on("message", bufferMessage);
+    const ctx = {
+      binaryType: "arraybuffer",
+      close(code, reason) {
+        ws.close(code, reason);
+      },
+      protocol: ws.protocol,
+      raw: ws,
+      get readyState() {
+        return ws.readyState;
+      },
+      send(source, opts) {
+        ws.send(source, { compress: opts?.compress });
+      },
+      url: new URL(c.req.url)
+    };
+    try {
+      events?.onOpen?.(new Event("open"), ctx);
+    } catch (e2) {
+      (options?.onError ?? console.error)(e2);
+    }
+    const handleMessage = (data, isBinary) => {
+      const datas = Array.isArray(data) ? data : [data];
+      for (const data2 of datas)
+        try {
+          events?.onMessage?.(new MessageEvent("message", { data: isBinary ? data2 instanceof ArrayBuffer ? data2 : data2.buffer.slice(data2.byteOffset, data2.byteOffset + data2.byteLength) : data2.toString("utf-8") }), ctx);
+        } catch (e2) {
+          (options?.onError ?? console.error)(e2);
+        }
+    };
+    ws.off("message", bufferMessage);
+    for (const message of messagesReceivedInStarting)
+      handleMessage(...message);
+    ws.on("message", (data, isBinary) => {
+      handleMessage(data, isBinary);
+    });
+    ws.on("close", (code, reason) => {
+      try {
+        events?.onClose?.(new CloseEvent2("close", {
+          code,
+          reason: reason.toString()
+        }), ctx);
+      } catch (e2) {
+        (options?.onError ?? console.error)(e2);
+      }
+    });
+    ws.on("error", (error48) => {
+      try {
+        events?.onError?.(new ErrorEvent("error", { error: error48 }), ctx);
+      } catch (e2) {
+        (options?.onError ?? console.error)(e2);
+      }
+    });
+  })();
+  return new Response;
+});
 var createAdaptorServer = (options) => {
   const fetchCallback = options.fetch;
   const requestListener = getRequestListener(fetchCallback, {
@@ -151703,8 +152241,16 @@ var createAdaptorServer = (options) => {
     overrideGlobalObjects: options.overrideGlobalObjects,
     autoCleanupIncoming: options.autoCleanupIncoming
   });
-  const createServer = options.createServer || createServerHTTP;
-  const server = createServer(options.serverOptions || {}, requestListener);
+  const server = (options.createServer || createServer)(options.serverOptions || {}, requestListener);
+  if (options.websocket && options.websocket.server) {
+    if (options.websocket.server.options.noServer !== true)
+      throw new Error("WebSocket server must be created with { noServer: true } option");
+    setupWebSocket({
+      server,
+      fetchCallback,
+      wss: options.websocket.server
+    });
+  }
   return server;
 };
 var serve = (options, listeningListener) => {
@@ -153162,11 +153708,11 @@ class RemoteJWKSet {
     if (this.#pendingFetch && isCloudflareWorkers()) {
       this.#pendingFetch = undefined;
     }
-    this.#pendingFetch ||= fetchJwks(this.#url.href, this.#headers, AbortSignal.timeout(this.#timeoutDuration), this.#customFetch).then((json2) => {
-      this.#local = createLocalJWKSet(json2);
+    this.#pendingFetch ||= fetchJwks(this.#url.href, this.#headers, AbortSignal.timeout(this.#timeoutDuration), this.#customFetch).then((json3) => {
+      this.#local = createLocalJWKSet(json3);
       if (this.#cache) {
         this.#cache.uat = Date.now();
-        this.#cache.jwks = json2;
+        this.#cache.jwks = json3;
       }
       this.#jwksTimestamp = Date.now();
       this.#pendingFetch = undefined;
@@ -154143,8 +154689,8 @@ class StdioServerTransport {
   }
   send(message2) {
     return new Promise((resolve2) => {
-      const json2 = serializeMessage(message2);
-      if (this._stdout.write(json2)) {
+      const json3 = serializeMessage(message2);
+      if (this._stdout.write(json3)) {
         resolve2();
       } else {
         this._stdout.once("drain", resolve2);