@keystrokehq/keystroke 0.0.0-staging-20260714181321

package/dist/config.d.mts

@@ -0,0 +1,1316 @@
+import { S as OAuthTokenRefreshRegistry } from "./index-whyhiCRD.mjs";
+import { Context, Hono } from "hono";
+
+//#region ../oauth/dist/index.d.mts
+/** Shared state payload carried through the OAuth flow (identity + tenant captured at initiation). */
+type OAuthStateContext = {
+  userId?: string;
+  orgId?: string; /** Org URL slug for post-connect web landing (`/{orgSlug}/apps`). */
+  orgSlug?: string; /** Credential fan-out targets selected at initiation: one project-scoped instance each. */
+  projectIds?: string[]; /** Display names for `projectIds`, keyed by project id. */
+  projectNamesById?: Record<string, string>; /** Create an org-scoped credential instance on callback. */
+  orgCredential?: boolean; /** Create a user-scoped credential instance (owned by `userId`) on callback. */
+  userCredential?: boolean; /** Provider scopes requested at initiation; providers fall back to their defaults when absent. */
+  scopes?: string[]; /** User-chosen display label for materialized credential instances. */
+  credentialLabel?: string; /** When set, update this credential instance in place (reconnect) instead of creating a new row. */
+  credentialInstanceId?: string; /** App / provider key for credential materialization (MCP Composio callbacks). */
+  credentialKey?: string;
+};
+/** base64url-encoded JSON so the payload segment never contains the `.` state delimiter. */
+type OAuthMountMode = "all" | "initiate" | "callback";
+//#endregion
+//#region ../scheduler/dist/contract-GpxHe4g6.d.mts
+//#region src/types.d.ts
+type JobKind = "workflow" | "agent" | "trigger" | "trigger-overview" | "workflow-canvas-annotations" | "workflow-overview" | "runtime" | "maintenance";
+type JobTrigger = "api" | "cron" | "webhook" | "poll" | "retry" | "prompt";
+/**
+ * Identifies a run that dispatched this job as a child. The parent metadata
+ * survives the queue boundary so the child can resume its parent at a terminal
+ * outcome without treating the child as a separately-billable dispatch.
+ */
+type JobParent = {
+  kind: "workflow" | "agent";
+  runId: string;
+  targetId: string;
+  correlationId?: string;
+};
+type JobPayload = {
+  kind: JobKind;
+  targetId: string;
+  runId: string;
+  trigger: JobTrigger;
+  payload: unknown;
+  attempt: number;
+  maxAttempts: number; /** True when this delivery is the final retry attempt. */
+  exhaustedRetries?: boolean;
+  scheduledAt: Date;
+  jobId: string; /** Project scope for org-wide worker queues. */
+  projectId?: string; /** Parent run that dispatched this child job, when applicable. */
+  parent?: JobParent; /** Optional W3C trace context carrier (sibling of user payload). */
+  traceContext?: Record<string, string>;
+};
+type EnqueueInput = {
+  kind: JobKind;
+  targetId: string;
+  runId: string;
+  trigger: JobTrigger;
+  payload?: unknown;
+  scheduledAt?: Date;
+  attempt?: number;
+  maxAttempts?: number; /** Dedupe key — pg-boss singletonKey / BullMQ jobId. */
+  dedupeKey?: string; /** Project scope for org-wide worker queues. */
+  projectId?: string; /** Parent run that dispatched this child job, when applicable. */
+  parent?: JobParent; /** Optional W3C trace context carrier (sibling of user payload). */
+  traceContext?: Record<string, string>;
+};
+type JobHandler = (job: JobPayload) => Promise<void>;
+type CancelHandler = (runId: string) => void | Promise<void>;
+type StopFn = () => Promise<void> | void;
+type WorkerOptions = {
+  workerId?: string;
+  pollIntervalMs?: number;
+  leaseSweepIntervalMs?: number;
+};
+type JobQueue = {
+  enqueue(input: EnqueueInput): Promise<string>;
+  startWorker(handler: JobHandler, options?: WorkerOptions): Promise<StopFn>;
+  /**
+   * Temporarily lends a worker slot to a child while an agent job waits on it.
+   * Backends without a hard concurrency cap may omit it.
+   */
+  withLentSlot?<T>(fn: () => Promise<T>): Promise<T>;
+  publishCancel(runId: string): Promise<void>;
+  subscribeCancel(handler: CancelHandler): Promise<StopFn>;
+};
+//#endregion
+//#region src/contract.d.ts
+/**
+ * Inlined to keep the contract database-free — structurally identical to
+ * `@keystrokehq/database`'s `DatabaseDialect`. Importing it from the database
+ * package would re-introduce the dependency `./contract` exists to avoid.
+ */
+type DatabaseDialect = "postgres" | "sqlite";
+type SchedulerScope = "platform" | "project" | "organization";
+type SchedulerPluginContext = {
+  scope: SchedulerScope;
+  url?: string;
+  dialect?: DatabaseDialect;
+  projectId?: string;
+  organizationId?: string;
+};
+type TriggerScheduleSpec = {
+  triggerSlug: string;
+  kind: "cron" | "poll";
+  schedule: string; /** IANA timezone for schedule wall-clock fields. When omitted, UTC. */
+  timezone?: string; /** Project scope for org-wide worker queues. */
+  projectId?: string;
+};
+type TriggerScheduleSyncOptions = {
+  schedules: TriggerScheduleSpec[];
+  scheduleOverrides?: {
+    global?: string;
+    byTrigger?: Record<string, string>;
+  };
+};
+type TriggerSchedulerStartOptions = {
+  pollIntervalMs?: number;
+  batchSize?: number; /** When `organization`, claims due schedules across all projects in the org schema. */
+  scope?: "project" | "organization";
+};
+type TriggerScheduler = {
+  sync(options: TriggerScheduleSyncOptions): Promise<void>;
+  start(options?: TriggerSchedulerStartOptions): Promise<StopFn>; /** Register or refresh one trigger schedule in the firing backend. */
+  upsert?(spec: TriggerScheduleSpec, overrides?: TriggerScheduleSyncOptions["scheduleOverrides"]): Promise<void>;
+  remove?(triggerSlug: string, projectId?: string): Promise<void>;
+  fireDue?(asOf?: Date): Promise<number>;
+};
+type SchedulerPlugin = {
+  name: string;
+  createJobQueue(ctx: SchedulerPluginContext): Promise<JobQueue>;
+  createTriggerScheduler?(ctx: SchedulerPluginContext, queue: JobQueue): Promise<TriggerScheduler>;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/request/constants.d.ts
+declare const GET_MATCH_RESULT: unique symbol;
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/router.d.ts
+/**
+ * Type representing a map of parameter indices.
+ */
+type ParamIndexMap = Record<string, number>;
+/**
+ * Type representing a stash of parameters.
+ */
+type ParamStash = string[];
+/**
+ * Type representing a map of parameters.
+ */
+type Params = Record<string, string>;
+/**
+ * Type representing the result of a route match.
+ *
+ * The result can be in one of two formats:
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
+ * 2. An array of handlers with their corresponding parameter maps.
+ *
+ * Example:
+ *
+ * [[handler, paramIndexMap][], paramArray]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                     // '*'
+ *     [funcA,       {'id': 0}],              // '/user/:id/*'
+ *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
+ *   ],
+ *   ['123', 'abc']
+ * ]
+ * ```
+ *
+ * [[handler, params][]]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                             // '*'
+ *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
+ *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
+ *   ]
+ * ]
+ * ```
+ */
+type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/utils/body.d.ts
+type BodyDataValueDot = {
+  [x: string]: string | File | BodyDataValueDot;
+};
+type BodyDataValueDotAll = {
+  [x: string]: string | File | (string | File)[] | BodyDataValueDotAll;
+};
+type SimplifyBodyData<T> = { [K in keyof T]: string | File | (string | File)[] | BodyDataValueDotAll extends T[K] ? string | File | (string | File)[] | BodyDataValueDotAll : string | File | BodyDataValueDot extends T[K] ? string | File | BodyDataValueDot : string | File | (string | File)[] extends T[K] ? string | File | (string | File)[] : string | File } & {};
+type BodyDataValueComponent<T> = string | File | (T extends {
+  all: false;
+} ? never : T extends {
+  all: true;
+} | {
+  all: boolean;
+} ? (string | File)[] : never);
+type BodyDataValueObject<T> = {
+  [key: string]: BodyDataValueComponent<T> | BodyDataValueObject<T>;
+};
+type BodyDataValue<T> = BodyDataValueComponent<T> | (T extends {
+  dot: false;
+} ? never : T extends {
+  dot: true;
+} | {
+  dot: boolean;
+} ? BodyDataValueObject<T> : never);
+type BodyData<T extends Partial<ParseBodyOptions> = {}> = SimplifyBodyData<Record<string, BodyDataValue<T>>>;
+type ParseBodyOptions = {
+  /**
+   * Determines whether all fields with multiple values should be parsed as arrays.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('file', 'aaa')
+   * data.append('file', 'bbb')
+   * data.append('message', 'hello')
+   *
+   * If all is false:
+   * parseBody should return { file: 'bbb', message: 'hello' }
+   *
+   * If all is true:
+   * parseBody should return { file: ['aaa', 'bbb'], message: 'hello' }
+   */
+  all: boolean;
+  /**
+   * Determines whether all fields with dot notation should be parsed as nested objects.
+   * @default false
+   * @example
+   * const data = new FormData()
+   * data.append('obj.key1', 'value1')
+   * data.append('obj.key2', 'value2')
+   *
+   * If dot is false:
+   * parseBody should return { 'obj.key1': 'value1', 'obj.key2': 'value2' }
+   *
+   * If dot is true:
+   * parseBody should return { obj: { key1: 'value1', key2: 'value2' } }
+   */
+  dot: boolean;
+};
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/utils/headers.d.ts
+/**
+ * @module
+ * HTTP Headers utility.
+ */
+type RequestHeader = 'A-IM' | 'Accept' | 'Accept-Additions' | 'Accept-CH' | 'Accept-Charset' | 'Accept-Datetime' | 'Accept-Encoding' | 'Accept-Features' | 'Accept-Language' | 'Accept-Patch' | 'Accept-Post' | 'Accept-Ranges' | 'Accept-Signature' | 'Access-Control' | 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Access-Control-Request-Headers' | 'Access-Control-Request-Method' | 'Age' | 'Allow' | 'ALPN' | 'Alt-Svc' | 'Alt-Used' | 'Alternates' | 'AMP-Cache-Transform' | 'Apply-To-Redirect-Ref' | 'Authentication-Control' | 'Authentication-Info' | 'Authorization' | 'Available-Dictionary' | 'C-Ext' | 'C-Man' | 'C-Opt' | 'C-PEP' | 'C-PEP-Info' | 'Cache-Control' | 'Cache-Status' | 'Cal-Managed-ID' | 'CalDAV-Timezones' | 'Capsule-Protocol' | 'CDN-Cache-Control' | 'CDN-Loop' | 'Cert-Not-After' | 'Cert-Not-Before' | 'Clear-Site-Data' | 'Client-Cert' | 'Client-Cert-Chain' | 'Close' | 'CMCD-Object' | 'CMCD-Request' | 'CMCD-Session' | 'CMCD-Status' | 'CMSD-Dynamic' | 'CMSD-Static' | 'Concealed-Auth-Export' | 'Configuration-Context' | 'Connection' | 'Content-Base' | 'Content-Digest' | 'Content-Disposition' | 'Content-Encoding' | 'Content-ID' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-MD5' | 'Content-Range' | 'Content-Script-Type' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Style-Type' | 'Content-Type' | 'Content-Version' | 'Cookie' | 'Cookie2' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Embedder-Policy-Report-Only' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Opener-Policy-Report-Only' | 'Cross-Origin-Resource-Policy' | 'CTA-Common-Access-Token' | 'DASL' | 'Date' | 'DAV' | 'Default-Style' | 'Delta-Base' | 'Deprecation' | 'Depth' | 'Derived-From' | 'Destination' | 'Differential-ID' | 'Dictionary-ID' | 'Digest' | 'DPoP' | 'DPoP-Nonce' | 'Early-Data' | 'EDIINT-Features' | 'ETag' | 'Expect' | 'Expect-CT' | 'Expires' | 'Ext' | 'Forwarded' | 'From' | 'GetProfile' | 'Hobareg' | 'Host' | 'HTTP2-Settings' | 'If' | 'If-Match' | 'If-Modified-Since' | 'If-None-Match' | 'If-Range' | 'If-Schedule-Tag-Match' | 'If-Unmodified-Since' | 'IM' | 'Include-Referred-Token-Binding-ID' | 'Isolation' | 'Keep-Alive' | 'Label' | 'Last-Event-ID' | 'Last-Modified' | 'Link' | 'Link-Template' | 'Location' | 'Lock-Token' | 'Man' | 'Max-Forwards' | 'Memento-Datetime' | 'Meter' | 'Method-Check' | 'Method-Check-Expires' | 'MIME-Version' | 'Negotiate' | 'NEL' | 'OData-EntityId' | 'OData-Isolation' | 'OData-MaxVersion' | 'OData-Version' | 'Opt' | 'Optional-WWW-Authenticate' | 'Ordering-Type' | 'Origin' | 'Origin-Agent-Cluster' | 'OSCORE' | 'OSLC-Core-Version' | 'Overwrite' | 'P3P' | 'PEP' | 'PEP-Info' | 'Permissions-Policy' | 'PICS-Label' | 'Ping-From' | 'Ping-To' | 'Position' | 'Pragma' | 'Prefer' | 'Preference-Applied' | 'Priority' | 'ProfileObject' | 'Protocol' | 'Protocol-Info' | 'Protocol-Query' | 'Protocol-Request' | 'Proxy-Authenticate' | 'Proxy-Authentication-Info' | 'Proxy-Authorization' | 'Proxy-Features' | 'Proxy-Instruction' | 'Proxy-Status' | 'Public' | 'Public-Key-Pins' | 'Public-Key-Pins-Report-Only' | 'Range' | 'Redirect-Ref' | 'Referer' | 'Referer-Root' | 'Referrer-Policy' | 'Refresh' | 'Repeatability-Client-ID' | 'Repeatability-First-Sent' | 'Repeatability-Request-ID' | 'Repeatability-Result' | 'Replay-Nonce' | 'Reporting-Endpoints' | 'Repr-Digest' | 'Retry-After' | 'Safe' | 'Schedule-Reply' | 'Schedule-Tag' | 'Sec-GPC' | 'Sec-Purpose' | 'Sec-Token-Binding' | 'Sec-WebSocket-Accept' | 'Sec-WebSocket-Extensions' | 'Sec-WebSocket-Key' | 'Sec-WebSocket-Protocol' | 'Sec-WebSocket-Version' | 'Security-Scheme' | 'Server' | 'Server-Timing' | 'Set-Cookie' | 'Set-Cookie2' | 'SetProfile' | 'Signature' | 'Signature-Input' | 'SLUG' | 'SoapAction' | 'Status-URI' | 'Strict-Transport-Security' | 'Sunset' | 'Surrogate-Capability' | 'Surrogate-Control' | 'TCN' | 'TE' | 'Timeout' | 'Timing-Allow-Origin' | 'Topic' | 'Traceparent' | 'Tracestate' | 'Trailer' | 'Transfer-Encoding' | 'TTL' | 'Upgrade' | 'Urgency' | 'URI' | 'Use-As-Dictionary' | 'User-Agent' | 'Variant-Vary' | 'Vary' | 'Via' | 'Want-Content-Digest' | 'Want-Digest' | 'Want-Repr-Digest' | 'Warning' | 'WWW-Authenticate' | 'X-Content-Type-Options' | 'X-Frame-Options';
+type ResponseHeader = 'Access-Control-Allow-Credentials' | 'Access-Control-Allow-Headers' | 'Access-Control-Allow-Methods' | 'Access-Control-Allow-Origin' | 'Access-Control-Expose-Headers' | 'Access-Control-Max-Age' | 'Age' | 'Allow' | 'Cache-Control' | 'Clear-Site-Data' | 'Content-Disposition' | 'Content-Encoding' | 'Content-Language' | 'Content-Length' | 'Content-Location' | 'Content-Range' | 'Content-Security-Policy' | 'Content-Security-Policy-Report-Only' | 'Content-Type' | 'Cookie' | 'Cross-Origin-Embedder-Policy' | 'Cross-Origin-Opener-Policy' | 'Cross-Origin-Resource-Policy' | 'Date' | 'ETag' | 'Expires' | 'Last-Modified' | 'Location' | 'Permissions-Policy' | 'Pragma' | 'Retry-After' | 'Save-Data' | 'Sec-CH-Prefers-Color-Scheme' | 'Sec-CH-Prefers-Reduced-Motion' | 'Sec-CH-UA' | 'Sec-CH-UA-Arch' | 'Sec-CH-UA-Bitness' | 'Sec-CH-UA-Form-Factor' | 'Sec-CH-UA-Full-Version' | 'Sec-CH-UA-Full-Version-List' | 'Sec-CH-UA-Mobile' | 'Sec-CH-UA-Model' | 'Sec-CH-UA-Platform' | 'Sec-CH-UA-Platform-Version' | 'Sec-CH-UA-WoW64' | 'Sec-Fetch-Dest' | 'Sec-Fetch-Mode' | 'Sec-Fetch-Site' | 'Sec-Fetch-User' | 'Sec-GPC' | 'Server' | 'Server-Timing' | 'Service-Worker-Navigation-Preload' | 'Set-Cookie' | 'Strict-Transport-Security' | 'Timing-Allow-Origin' | 'Trailer' | 'Transfer-Encoding' | 'Upgrade' | 'Vary' | 'WWW-Authenticate' | 'Warning' | 'X-Content-Type-Options' | 'X-DNS-Prefetch-Control' | 'X-Frame-Options' | 'X-Permitted-Cross-Domain-Policies' | 'X-Powered-By' | 'X-Robots-Tag' | 'X-XSS-Protection';
+type CustomHeader = string & {};
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/utils/types.d.ts
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+type JSONPrimitive = string | boolean | number | null;
+type JSONArray = (JSONPrimitive | JSONObject | JSONArray)[];
+type JSONObject = {
+  [key: string]: JSONPrimitive | JSONArray | JSONObject | object | InvalidJSONValue;
+};
+type InvalidJSONValue = undefined | symbol | ((...args: unknown[]) => unknown);
+type InvalidToNull<T> = T extends InvalidJSONValue ? null : T;
+type IsInvalid<T> = T extends InvalidJSONValue ? true : false;
+/**
+ * symbol keys are omitted through `JSON.stringify`
+ */
+type OmitSymbolKeys<T> = { [K in keyof T as K extends symbol ? never : K]: T[K] };
+type JSONValue = JSONObject | JSONArray | JSONPrimitive;
+/**
+ * Convert a type to a JSON-compatible type.
+ *
+ * Non-JSON values such as `Date` implement `.toJSON()`,
+ * so they can be transformed to a value assignable to `JSONObject`
+ *
+ * `JSON.stringify()` throws a `TypeError` when it encounters a `bigint` value,
+ * unless a custom `replacer` function or `.toJSON()` method is provided.
+ *
+ * This behaviour can be controlled by the `TError` generic type parameter,
+ * which defaults to `bigint | ReadonlyArray<bigint>`.
+ * You can set it to `never` to disable this check.
+ */
+type JSONParsed<T, TError = bigint | ReadonlyArray<bigint>> = T extends {
+  toJSON(): infer J;
+} ? (() => J) extends (() => JSONPrimitive) ? J : (() => J) extends (() => {
+  toJSON(): unknown;
+}) ? {} : JSONParsed<J, TError> : T extends JSONPrimitive ? T : T extends InvalidJSONValue ? never : T extends ReadonlyArray<unknown> ? { [K in keyof T]: JSONParsed<InvalidToNull<T[K]>, TError> } : T extends Set<unknown> | Map<unknown, unknown> | Record<string, never> ? {} : T extends object ? T[keyof T] extends TError ? never : { [K in keyof OmitSymbolKeys<T> as IsInvalid<T[K]> extends true ? never : K]: boolean extends IsInvalid<T[K]> ? JSONParsed<T[K], TError> | undefined : JSONParsed<T[K], TError> } : T extends unknown ? T extends TError ? never : JSONValue : never;
+/**
+ * Useful to flatten the type output to improve type hints shown in editors. And also to transform an interface into a type to aide with assignability.
+ * @copyright from sindresorhus/type-fest
+ */
+type Simplify<T> = { [KeyType in keyof T]: T[KeyType] } & {};
+type IsAny<T> = boolean extends (T extends never ? true : false) ? true : false;
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/request.d.ts
+type Body = {
+  json: any;
+  text: string;
+  arrayBuffer: ArrayBuffer;
+  blob: Blob;
+  formData: FormData;
+};
+type BodyCache = Partial<Body>;
+declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
+  /**
+   * `.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: Request;
+  routeIndex: number;
+  /**
+   * `.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: string;
+  bodyCache: BodyCache;
+  constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
+  /**
+   * `.req.param()` gets the path parameters.
+   *
+   * @see {@link https://hono.dev/docs/api/routing#path-parameter}
+   *
+   * @example
+   * ```ts
+   * const name = c.req.param('name')
+   * // or all parameters at once
+   * const { id, comment_id } = c.req.param()
+   * ```
+   */
+  param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
+  param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
+  param(key: string): string | undefined;
+  param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
+  /**
+   * `.query()` can get querystring parameters.
+   *
+   * @see {@link https://hono.dev/docs/api/request#query}
+   *
+   * @example
+   * ```ts
+   * // Query params
+   * app.get('/search', (c) => {
+   *   const query = c.req.query('q')
+   * })
+   *
+   * // Get all params at once
+   * app.get('/search', (c) => {
+   *   const { q, limit, offset } = c.req.query()
+   * })
+   * ```
+   */
+  query(key: string): string | undefined;
+  query(): Record<string, string>;
+  /**
+   * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
+   *
+   * @see {@link https://hono.dev/docs/api/request#queries}
+   *
+   * @example
+   * ```ts
+   * app.get('/search', (c) => {
+   *   // tags will be string[]
+   *   const tags = c.req.queries('tags')
+   * })
+   * ```
+   */
+  queries(key: string): string[] | undefined;
+  queries(): Record<string, string[]>;
+  /**
+   * `.header()` can get the request header value.
+   *
+   * @see {@link https://hono.dev/docs/api/request#header}
+   *
+   * @example
+   * ```ts
+   * app.get('/', (c) => {
+   *   const userAgent = c.req.header('User-Agent')
+   * })
+   * ```
+   */
+  header(name: RequestHeader): string | undefined;
+  header(name: string): string | undefined;
+  header(): Record<RequestHeader | (string & CustomHeader), string>;
+  /**
+   * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
+   *
+   * @see {@link https://hono.dev/docs/api/request#parsebody}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.parseBody()
+   * })
+   * ```
+   */
+  parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
+  parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
+  /**
+   * `.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<T = any>(): Promise<T>;
+  /**
+   * `.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(): Promise<string>;
+  /**
+   * `.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(): Promise<ArrayBuffer>;
+  /**
+   * `.bytes()` parses the request body as a `Uint8Array`.
+   *
+   * @see {@link https://hono.dev/docs/api/request#bytes}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.bytes()
+   * })
+   * ```
+   */
+  bytes(): Promise<Uint8Array>;
+  /**
+   * 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(): Promise<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(): Promise<FormData>;
+  /**
+   * Adds validated data to the request.
+   *
+   * @param target - The target of the validation.
+   * @param data - The validated data to add.
+   */
+  addValidatedData(target: keyof ValidationTargets, data: {}): void;
+  /**
+   * Gets validated data from the request.
+   *
+   * @param target - The target of the validation.
+   * @returns The validated data.
+   *
+   * @see https://hono.dev/docs/api/request#valid
+   */
+  valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
+  /**
+   * `.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(): string;
+  /**
+   * `.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(): string;
+  get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
+  /**
+   * `.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(): RouterRoute[];
+  /**
+   * `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(): string;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/utils/http-status.d.ts
+/**
+ * @module
+ * HTTP Status utility.
+ */
+type InfoStatusCode = 100 | 101 | 102 | 103;
+type SuccessStatusCode = 200 | 201 | 202 | 203 | 204 | 205 | 206 | 207 | 208 | 226;
+type DeprecatedStatusCode = 305 | 306;
+type RedirectStatusCode = 300 | 301 | 302 | 303 | 304 | DeprecatedStatusCode | 307 | 308;
+type ClientErrorStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451;
+type ServerErrorStatusCode = 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+/**
+ * `UnofficialStatusCode` can be used to specify an unofficial status code.
+ * @example
+ *
+ * ```ts
+ * app.get('/unknown', (c) => {
+ *   return c.text("Unknown Error", 520 as UnofficialStatusCode)
+ * })
+ * ```
+ */
+type UnofficialStatusCode = -1;
+/**
+ * If you want to use an unofficial status, use `UnofficialStatusCode`.
+ */
+type StatusCode = InfoStatusCode | SuccessStatusCode | RedirectStatusCode | ClientErrorStatusCode | ServerErrorStatusCode | UnofficialStatusCode;
+type ContentlessStatusCode = 101 | 204 | 205 | 304;
+type ContentfulStatusCode = Exclude<StatusCode, ContentlessStatusCode>;
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/utils/mime.d.ts
+/**
+ * Union types for BaseMime
+ */
+type BaseMime = (typeof _baseMimes)[keyof typeof _baseMimes];
+declare const _baseMimes: {
+  readonly aac: "audio/aac";
+  readonly avi: "video/x-msvideo";
+  readonly avif: "image/avif";
+  readonly av1: "video/av1";
+  readonly bin: "application/octet-stream";
+  readonly bmp: "image/bmp";
+  readonly css: "text/css; charset=utf-8";
+  readonly csv: "text/csv; charset=utf-8";
+  readonly eot: "application/vnd.ms-fontobject";
+  readonly epub: "application/epub+zip";
+  readonly gif: "image/gif";
+  readonly gz: "application/gzip";
+  readonly htm: "text/html; charset=utf-8";
+  readonly html: "text/html; charset=utf-8";
+  readonly ico: "image/x-icon";
+  readonly ics: "text/calendar; charset=utf-8";
+  readonly jpeg: "image/jpeg";
+  readonly jpg: "image/jpeg";
+  readonly js: "text/javascript; charset=utf-8";
+  readonly json: "application/json";
+  readonly jsonld: "application/ld+json";
+  readonly map: "application/json";
+  readonly mid: "audio/x-midi";
+  readonly midi: "audio/x-midi";
+  readonly mjs: "text/javascript; charset=utf-8";
+  readonly mp3: "audio/mpeg";
+  readonly mp4: "video/mp4";
+  readonly mpeg: "video/mpeg";
+  readonly oga: "audio/ogg";
+  readonly ogv: "video/ogg";
+  readonly ogx: "application/ogg";
+  readonly opus: "audio/opus";
+  readonly otf: "font/otf";
+  readonly pdf: "application/pdf";
+  readonly png: "image/png";
+  readonly rtf: "application/rtf";
+  readonly svg: "image/svg+xml; charset=utf-8";
+  readonly tif: "image/tiff";
+  readonly tiff: "image/tiff";
+  readonly ts: "video/mp2t";
+  readonly ttf: "font/ttf";
+  readonly txt: "text/plain; charset=utf-8";
+  readonly wasm: "application/wasm";
+  readonly webm: "video/webm";
+  readonly weba: "audio/webm";
+  readonly webmanifest: "application/manifest+json";
+  readonly webp: "image/webp";
+  readonly woff: "font/woff";
+  readonly woff2: "font/woff2";
+  readonly xhtml: "application/xhtml+xml; charset=utf-8";
+  readonly xml: "application/xml; charset=utf-8";
+  readonly zip: "application/zip";
+  readonly '3gp': "video/3gpp";
+  readonly '3g2': "video/3gpp2";
+  readonly gltf: "model/gltf+json";
+  readonly glb: "model/gltf-binary";
+};
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/context.d.ts
+type HeaderRecord = Record<'Content-Type', BaseMime> | Record<ResponseHeader, string | string[]> | Record<string, string | string[]>;
+/**
+ * Data type can be a string, ArrayBuffer, Uint8Array (buffer), or ReadableStream.
+ */
+type Data = string | ArrayBuffer | ReadableStream | Uint8Array<ArrayBuffer>;
+/**
+ * Interface for the execution context in a web worker or similar environment.
+ */
+interface ExecutionContext {
+  /**
+   * Extends the lifetime of the event callback until the promise is settled.
+   *
+   * @param promise - A promise to wait for.
+   */
+  waitUntil(promise: Promise<unknown>): void;
+  /**
+   * Allows the event to be passed through to subsequent event listeners.
+   */
+  passThroughOnException(): void;
+  /**
+   * For compatibility with Wrangler 4.x.
+   */
+  props: any;
+  /**
+   * For compatibility with Wrangler 4.x.
+   */
+  exports?: any;
+}
+/**
+ * Interface for context variable mapping.
+ */
+interface ContextVariableMap {}
+/**
+ * Interface for context renderer.
+ */
+interface ContextRenderer {}
+/**
+ * Interface representing a renderer for content.
+ *
+ * @interface DefaultRenderer
+ * @param {string | Promise<string>} content - The content to be rendered, which can be either a string or a Promise resolving to a string.
+ * @returns {Response | Promise<Response>} - The response after rendering the content, which can be either a Response or a Promise resolving to a Response.
+ */
+interface DefaultRenderer {
+  (content: string | Promise<string>): Response | Promise<Response>;
+}
+/**
+ * Renderer type which can either be a ContextRenderer or DefaultRenderer.
+ */
+type Renderer = ContextRenderer extends Function ? ContextRenderer : DefaultRenderer;
+/**
+ * Extracts the props for the renderer.
+ */
+type PropsForRenderer = [...Required<Parameters<Renderer>>] extends [unknown, infer Props] ? Props : unknown;
+type Layout<T = Record<string, any>> = (props: T) => any;
+/**
+ * Interface for getting context variables.
+ *
+ * @template E - Environment type.
+ */
+interface Get<E extends Env> {
+  <Key extends keyof E['Variables']>(key: Key): E['Variables'][Key];
+  <Key extends keyof ContextVariableMap>(key: Key): ContextVariableMap[Key];
+}
+/**
+ * Interface for setting context variables.
+ *
+ * @template E - Environment type.
+ */
+interface Set$1<E extends Env> {
+  <Key extends keyof E['Variables']>(key: Key, value: E['Variables'][Key]): void;
+  <Key extends keyof ContextVariableMap>(key: Key, value: ContextVariableMap[Key]): void;
+}
+/**
+ * Interface for creating a new response.
+ */
+interface NewResponse {
+  (data: Data | null, status?: StatusCode, headers?: HeaderRecord): Response;
+  (data: Data | null, init?: ResponseOrInit): Response;
+}
+/**
+ * Interface for responding with a body.
+ */
+interface BodyRespond {
+  <T extends Data, U extends ContentfulStatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'body'>;
+  <T extends Data, U extends ContentfulStatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'body'>;
+  <T extends null, U extends StatusCode>(data: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<null, U, 'body'>;
+  <T extends null, U extends StatusCode>(data: T, init?: ResponseOrInit<U>): Response & TypedResponse<null, U, 'body'>;
+}
+/**
+ * Interface for responding with text.
+ *
+ * @interface TextRespond
+ * @template T - The type of the text content.
+ * @template U - The type of the status code.
+ *
+ * @param {T} text - The text content to be included in the response.
+ * @param {U} [status] - An optional status code for the response.
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
+ *
+ * @returns {Response & TypedResponse<T, U, 'text'>} - The response after rendering the text content, typed with the provided text and status code types.
+ */
+interface TextRespond {
+  <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, status?: U, headers?: HeaderRecord): Response & TypedResponse<T, U, 'text'>;
+  <T extends string, U extends ContentfulStatusCode = ContentfulStatusCode>(text: T, init?: ResponseOrInit<U>): Response & TypedResponse<T, U, 'text'>;
+}
+/**
+ * Interface for responding with JSON.
+ *
+ * @interface JSONRespond
+ * @template T - The type of the JSON value or simplified unknown type.
+ * @template U - The type of the status code.
+ *
+ * @param {T} object - The JSON object to be included in the response.
+ * @param {U} [status] - An optional status code for the response.
+ * @param {HeaderRecord} [headers] - An optional record of headers to include in the response.
+ *
+ * @returns {JSONRespondReturn<T, U>} - The response after rendering the JSON object, typed with the provided object and status code types.
+ */
+interface JSONRespond {
+  <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, status?: U, headers?: HeaderRecord): JSONRespondReturn<T, U>;
+  <T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode = ContentfulStatusCode>(object: T, init?: ResponseOrInit<U>): JSONRespondReturn<T, U>;
+}
+/**
+ * @template T - The type of the JSON value or simplified unknown type.
+ * @template U - The type of the status code.
+ *
+ * @returns {Response & TypedResponse<JSONParsed<T>, U, 'json'>} - The response after rendering the JSON object, typed with the provided object and status code types.
+ */
+type JSONRespondReturn<T extends JSONValue | {} | InvalidJSONValue, U extends ContentfulStatusCode> = Response & TypedResponse<JSONParsed<T>, U, 'json'>;
+/**
+ * Interface representing a function that responds with HTML content.
+ *
+ * @param html - The HTML content to respond with, which can be a string or a Promise that resolves to a string.
+ * @param status - (Optional) The HTTP status code for the response.
+ * @param headers - (Optional) A record of headers to include in the response.
+ * @param init - (Optional) The response initialization object.
+ *
+ * @returns A Response object or a Promise that resolves to a Response object.
+ */
+interface HTMLRespond {
+  <T extends string | Promise<string>>(html: T, status?: ContentfulStatusCode, headers?: HeaderRecord): T extends string ? Response : Promise<Response>;
+  <T extends string | Promise<string>>(html: T, init?: ResponseOrInit<ContentfulStatusCode>): T extends string ? Response : Promise<Response>;
+}
+/**
+ * Options for configuring the context.
+ *
+ * @template E - Environment type.
+ */
+type ContextOptions<E extends Env> = {
+  /**
+   * Bindings for the environment.
+   */
+  env: E['Bindings'];
+  /**
+   * Execution context for the request.
+   */
+  executionCtx?: FetchEventLike | ExecutionContext | undefined;
+  /**
+   * Handler for not found responses.
+   */
+  notFoundHandler?: NotFoundHandler<E>;
+  matchResult?: Result<[H, RouterRoute]>;
+  path?: string;
+};
+interface SetHeadersOptions {
+  append?: boolean;
+}
+interface SetHeaders {
+  (name: 'Content-Type', value?: BaseMime, options?: SetHeadersOptions): void;
+  (name: ResponseHeader, value?: string, options?: SetHeadersOptions): void;
+  (name: string, value?: string, options?: SetHeadersOptions): void;
+}
+type ResponseHeadersInit = [string, string][] | Record<'Content-Type', BaseMime> | Record<ResponseHeader, string> | Record<string, string> | Headers;
+interface ResponseInit<T extends StatusCode = StatusCode> {
+  headers?: ResponseHeadersInit;
+  status?: T;
+  statusText?: string;
+}
+type ResponseOrInit<T extends StatusCode = StatusCode> = ResponseInit<T> | Response;
+declare class Context$1<E extends Env = any, P extends string = any, I extends Input = {}> {
+  /**
+   * `.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: E['Bindings'];
+  finalized: boolean;
+  /**
+   * `.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: Error | undefined;
+  /**
+   * Creates an instance of the Context class.
+   *
+   * @param req - The Request object.
+   * @param options - Optional configuration options for the context.
+   */
+  constructor(req: Request, options?: ContextOptions<E>);
+  /**
+   * `.req` is the instance of {@link HonoRequest}.
+   */
+  get req(): HonoRequest<P, I['out']>;
+  /**
+   * @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(): FetchEventLike;
+  /**
+   * @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(): ExecutionContext;
+  /**
+   * @see {@link https://hono.dev/docs/api/context#res}
+   * The Response object for the current request.
+   */
+  get res(): Response;
+  /**
+   * Sets the Response object for the current request.
+   *
+   * @param _res - The Response object to set.
+   */
+  set res(_res: Response | undefined);
+  /**
+   * `.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: Renderer;
+  /**
+   * Sets the layout for the response.
+   *
+   * @param layout - The layout to set.
+   * @returns The layout function.
+   */
+  setLayout: (layout: Layout<PropsForRenderer & {
+    Layout: Layout;
+  }>) => Layout<PropsForRenderer & {
+    Layout: Layout;
+  }>;
+  /**
+   * Gets the current layout for the response.
+   *
+   * @returns The current layout function.
+   */
+  getLayout: () => Layout<PropsForRenderer & {
+    Layout: Layout;
+  }> | undefined;
+  /**
+   * `.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: Renderer) => void;
+  /**
+   * `.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: SetHeaders;
+  status: (status: StatusCode) => void;
+  /**
+   * `.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: Set$1<IsAny<E> extends true ? {
+    Variables: ContextVariableMap & Record<string, any>;
+  } : E>;
+  /**
+   * `.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: Get<IsAny<E> extends true ? {
+    Variables: ContextVariableMap & Record<string, any>;
+  } : E>;
+  /**
+   * `.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()
+   * ```
+   */
+  get var(): Readonly<ContextVariableMap & (IsAny<E['Variables']> extends true ? Record<string, any> : E['Variables'])>;
+  newResponse: NewResponse;
+  /**
+   * `.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: BodyRespond;
+  /**
+   * `.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: TextRespond;
+  /**
+   * `.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: JSONRespond;
+  html: HTMLRespond;
+  /**
+   * `.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: <T extends RedirectStatusCode = 302>(location: string | URL, status?: T) => Response & TypedResponse<undefined, T, "redirect">;
+  /**
+   * `.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: () => ReturnType<NotFoundHandler>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/hono@4.12.22/node_modules/hono/dist/types/types.d.ts
+type Bindings = object;
+type Variables = object;
+type Env = {
+  Bindings?: Bindings;
+  Variables?: Variables;
+};
+type Next = () => Promise<void>;
+type Input = {
+  in?: {};
+  out?: {};
+  outputFormat?: ResponseFormat;
+};
+type BlankInput = {};
+interface RouterRoute {
+  basePath: string;
+  path: string;
+  method: string;
+  handler: H;
+}
+type HandlerResponse<O> = Response | TypedResponse<O> | Promise<Response | TypedResponse<O>> | Promise<void>;
+type Handler<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = (c: Context$1<E, P, I>, next: Next) => R;
+type MiddlewareHandler<E extends Env = any, P extends string = string, I extends Input = {}, R extends HandlerResponse<any> = Response> = (c: Context$1<E, P, I>, next: Next) => Promise<R | void>;
+type H<E extends Env = any, P extends string = any, I extends Input = BlankInput, R extends HandlerResponse<any> = any> = Handler<E, P, I, R> | MiddlewareHandler<E, P, I, R>;
+/**
+ * You can extend this interface to define a custom `c.notFound()` Response type.
+ *
+ * @example
+ * declare module 'hono' {
+ *   interface NotFoundResponse extends Response, TypedResponse<string, 404, 'text'> {}
+ * }
+ */
+interface NotFoundResponse {}
+type NotFoundHandler<E extends Env = any> = (c: Context$1<E>) => NotFoundResponse extends Response ? NotFoundResponse | Promise<NotFoundResponse> : Response | Promise<Response>;
+type KnownResponseFormat = 'json' | 'text' | 'redirect';
+type ResponseFormat = KnownResponseFormat | string;
+type TypedResponse<T = unknown, U extends StatusCode = StatusCode, F extends ResponseFormat = (T extends string ? 'text' : T extends JSONValue ? 'json' : ResponseFormat)> = {
+  _data: T;
+  _status: U;
+  _format: F;
+};
+type FormValue = string | Blob;
+type ParsedFormValue = string | File;
+type ValidationTargets<T extends FormValue = ParsedFormValue, P extends string = string> = {
+  json: any;
+  form: Record<string, T | T[]>;
+  query: Record<string, string | string[]>;
+  param: Record<P, P extends `${infer _}?` ? string | undefined : string>;
+  header: Record<RequestHeader | CustomHeader, string>;
+  cookie: Record<string, string>;
+};
+type ParamKey<Component> = Component extends `:${infer NameWithPattern}` ? NameWithPattern extends `${infer Name}{${infer Rest}` ? Rest extends `${infer _Pattern}?` ? `${Name}?` : Name : NameWithPattern : never;
+type ParamKeys<Path> = Path extends `${infer Component}/${infer Rest}` ? ParamKey<Component> | ParamKeys<Rest> : ParamKey<Path>;
+type ParamKeyToRecord<T extends string> = T extends `${infer R}?` ? Record<R, string | undefined> : { [K in T]: string };
+type InputToDataByTarget<T extends Input['out'], Target extends keyof ValidationTargets> = T extends { [K in Target]: infer R } ? R : never;
+type RemoveQuestion<T> = T extends `${infer R}?` ? R : T;
+declare abstract class FetchEventLike {
+  abstract readonly request: Request;
+  abstract respondWith(promise: Response | Promise<Response>): void;
+  abstract passThroughOnException(): void;
+  abstract waitUntil(promise: Promise<void>): void;
+}
+//#endregion
+//#region ../config/dist/index.d.mts
+//#region src/plugins.d.ts
+type PluginHttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type PluginRouteManifestEntry = {
+  kind: "plugin";
+  method: PluginHttpMethod;
+  path: string;
+  plugin: string;
+};
+type PluginOAuthAdapter = {
+  getAccessToken(connectionId: string): Promise<{
+    accessToken: string;
+  }>;
+};
+type AuthenticatedUser = {
+  id: string;
+};
+type PluginRunPromptOptions = {
+  workspacesRoot?: string;
+  oauthAdapter?: PluginOAuthAdapter;
+  runtimeHooks?: unknown;
+  runtimeProvider?: unknown;
+  hostTools?: unknown[];
+};
+/** Where a gateway reply should be posted (e.g. a Slack thread). Platform-agnostic, no agent types. */
+type GatewayReplyTarget = {
+  platform: string;
+  threadId: string;
+  channelId: string;
+  threadTs?: string; /** Slack workspace (team) id — required for correct bot token when multiple workspaces are connected. */
+  teamId?: string;
+  /**
+   * OAuth connection id for the workspace, resolved at enqueue time. Lets the worker materialize the
+   * exact workspace's bot token instead of the default credential when multiple workspaces are connected.
+   */
+  connectionId?: string; /** Display name for chat.postMessage username override (requires chat:write.customize). */
+  agentName?: string;
+  attachmentId: string;
+  attachmentSlug: string;
+};
+/** Minimal agent result the worker hands to a gateway replier (kept free of agent/gateway types). */
+type GatewayReplyResult = {
+  text: string | null;
+  error?: string | null;
+};
+/** Posts a finished agent result back to the originating chat platform. Registered by gateway plugins. */
+type GatewayReplier = (target: GatewayReplyTarget, result: GatewayReplyResult) => Promise<void>;
+/** Shows a typing/processing indicator on the gateway thread while an enqueued agent job runs. */
+type GatewayTypingStarter = (target: GatewayReplyTarget) => Promise<void>;
+type PluginServices = {
+  agents: {
+    byKey: ReadonlyMap<string, unknown>;
+    idByKey: ReadonlyMap<string, string>;
+  };
+  oauthAdapter?: PluginOAuthAdapter;
+  tokenRefresh?: OAuthTokenRefreshRegistry;
+  getAuthenticatedUser?: (headers: Headers) => Promise<AuthenticatedUser | null>; /** Public platform API origin for OAuth redirect_uri (`PUBLIC_PLATFORM_URL/api`). */
+  resolvePublicPlatformApiUrl?: () => string | undefined; /** Extra signed-state context (e.g. orgId) captured at OAuth initiation, trusted at the callback. */
+  resolveStateContext?: (c: Context) => OAuthStateContext | Promise<OAuthStateContext>; /** Re-establish persistence scope at the unauthenticated OAuth callback from the verified state. */
+  runInStateContext?: <T>(ctx: OAuthStateContext, fn: () => Promise<T>) => Promise<T>; /** Restrict which OAuth routes mount (initiation vs callback). Default `all`. */
+  oauthMountMode?: OAuthMountMode; /** When false, skip OAuth route registration (e.g. project gateway-only mount). Default true. */
+  includeOAuth?: boolean; /** When false, skip gateway webhook registration (e.g. org OAuth-only mount). Default true. */
+  includeGateway?: boolean;
+  runPrompt: () => PluginRunPromptOptions; /** Per-agent prompt options (e.g. host-injected tools). Merged over `runPrompt()` at fire time. */
+  runPromptFor?: (agentKey: string) => PluginRunPromptOptions;
+  getPgPool?: () => unknown; /** Register a worker-side replier for a chat gateway platform (e.g. "slack"). */
+  registerGatewayReplier?: (platform: string, replier: GatewayReplier) => void; /** Register a worker-side typing indicator for a chat gateway platform (e.g. "slack"). */
+  registerGatewayTypingStarter?: (platform: string, starter: GatewayTypingStarter) => void;
+};
+type PluginContext = {
+  mountRoute(entry: PluginRouteManifestEntry, handler: MiddlewareHandler): void;
+  services: PluginServices;
+};
+type ServerPlugin = {
+  name: string;
+  register(ctx: PluginContext): void | Promise<void>;
+};
+type IntegrationMount = (ctx: PluginContext) => void | Promise<void>;
+type KeystrokeModuleDirs = {
+  agentsDir?: string;
+  workflowsDir?: string;
+  triggersDir?: string;
+  actionsDir?: string;
+};
+type KeystrokeServerConfig = {
+  /**
+   * Optional override. When omitted, local project servers use SQLite at
+   * `file:./data/dev.db` (via `DATABASE_URL` or `@keystrokehq/database` default).
+   */
+  database?: {
+    url?: string;
+    migrate?: boolean;
+  };
+  executionMode?: "inline" | "queued"; /** Default-on web search tools for every agent. Defaults to true when unset. */
+  webSearch?: boolean;
+};
+type KeystrokeConfig = {
+  integrations?: Array<{
+    key: string;
+    mount: IntegrationMount;
+  }>; /** @deprecated Use integrations instead */
+  plugins?: ServerPlugin[];
+  dirs?: KeystrokeModuleDirs; /** Queue backend for queued execution. Defaults to pg-boss (Postgres) or DB polling (SQLite). */
+  scheduler?: SchedulerPlugin;
+  server?: KeystrokeServerConfig; /** Platform project slug this directory deploys to. Optional; set via `keystroke projects link`. */
+  project?: string; /** Platform organization slug. Optional; usually auto-filled by `keystroke projects link`. */
+  organization?: string;
+};
+type CreatePluginContextOptions = {
+  app: Hono;
+  manifest: PluginRouteManifestEntry[];
+  mountedRoutes: Set<string>;
+  services: PluginServices;
+};
+declare function createPluginContext(options: CreatePluginContextOptions): PluginContext;
+declare function registerPlugins(plugins: ServerPlugin[], ctx: PluginContext): Promise<void>; //#endregion
+//#region src/define-config.d.ts
+declare function defineConfig(config: KeystrokeConfig): KeystrokeConfig; //#endregion
+//#region src/load-config.d.ts
+declare function loadConfig(cwd: string): Promise<KeystrokeConfig>; //#endregion
+//#region src/integrations.d.ts
+type IntegrationContext = PluginContext;
+type IntegrationServices = PluginServices;
+type Integration = {
+  key: string;
+  mount: IntegrationMount;
+};
+declare function defineIntegration(options: {
+  key: string;
+  mount: IntegrationMount;
+}): Integration;
+declare function mountIntegrations(integrations: Integration[], ctx: IntegrationContext, options?: {
+  tokenRefresh?: OAuthTokenRefreshRegistry;
+}): Promise<void>;
+declare function collectIntegrationKeys(integrations: Integration[]): string[]; //#endregion
+//#endregion
+export { type GatewayReplier, type GatewayReplyResult, type GatewayReplyTarget, type GatewayTypingStarter, type Integration, type IntegrationContext, type IntegrationServices, type KeystrokeConfig, type PluginContext, type PluginServices, type ServerPlugin, collectIntegrationKeys, createPluginContext, defineConfig, defineIntegration, loadConfig, mountIntegrations, registerPlugins };
+//# sourceMappingURL=config.d.mts.map