@ozanarslan/corpus-cli 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1178 @@
+import fs from "fs";
+import "oxc-parser";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+//#region ../corpus/dist/utils/is.d.ts
+type Nullable<T> = T | null;
+type Optional<T> = T | undefined;
+type Maybe<T> = Optional<Nullable<T>>;
+type MaybePromise<T> = T | Promise<T>;
+type MaybeArray<T> = T | Array<T>;
+type OrString$1<T> = T | (string & {});
+//#endregion
+//#region ../corpus/dist/Cookies/index.d.ts
+/**
+ * A cookie map with header-parsing constructors.
+ *
+ * Everything `Bun.CookieMap` offers is available unchanged; the two static
+ * methods are the additions. Use {@link Cookies.fromHeader} for what a client
+ * sent and {@link Cookies.fromSetCookieHeaders} for what a server is sending
+ * back — reading a response's own cookies, or following them in a client.
+ */
+declare class Cookies extends Bun.CookieMap {
+  /**
+   * Creates a cookie map, forwarding to the native constructor.
+   *
+   * `Bun.CookieMap` is a native class that ignores `new.target`, so instances
+   * come back with the base prototype and none of the subclass members attached.
+   * The prototype is reattached here, which is what makes subclassing work at
+   * all.
+   *
+   * @param args - The native {@link Bun.CookieMap} constructor arguments.
+   */
+  constructor(...args: ConstructorParameters<typeof Bun.CookieMap>);
+  /**
+   * Builds a map from an inbound `Cookie` header.
+   *
+   * @param cookieHeader - The raw `Cookie` header value, as sent by the client.
+   * @returns The cookies it carried. Repeated names resolve to the last
+   * occurrence.
+   */
+  static fromHeader(cookieHeader: string): Cookies;
+  /**
+   * Builds a map from outbound `Set-Cookie` headers, preserving each cookie's
+   * attributes.
+   *
+   * @param headers - The raw `Set-Cookie` values, one per cookie.
+   * @returns The cookies they describe. Repeated names resolve to the last
+   * occurrence.
+   */
+  static fromSetCookieHeaders(headers: string[]): Cookies;
+}
+//#endregion
+//#region ../corpus/dist/utils/object.d.ts
+type ValueOf<T> = T[keyof T];
+declare global {
+  interface ObjectConstructor {
+    keys<O extends object>(o: O): Array<keyof O>;
+    values<O extends object>(o: O): Array<O[keyof O]>;
+    entries<O extends object>(o: O): Array<[keyof O, O[keyof O]]>;
+  }
+}
+//#endregion
+//#region ../corpus/dist/Headers/index.d.ts
+/**
+ * A value accepted by the patched header setters. Numbers and booleans are
+ * stringified on the way in, so a byte length or a flag can be passed as-is.
+ */
+type HeadersInitValue = string | number | boolean;
+/**
+ * What {@link Headers.setMany} accepts: entry pairs, a plain object, or another
+ * `Headers` instance.
+ */
+type CustomHeadersInit = [string, HeadersInitValue][] | Record<string, HeadersInitValue> | Headers;
+/** Just some common headers. See [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers) for the full spec. */
+declare const HeaderKey: {
+  /** Controls caching mechanisms for requests and responses. */
+  readonly CacheControl: "Cache-Control";
+  /** Specifies the media type of the resource or data. */
+  readonly ContentType: "Content-Type";
+  /** Indicates the size of the entity-body in bytes. */
+  readonly ContentLength: "Content-Length";
+  /** Whether to display payload inline within the page or prompt the user to download it as an attachment. */
+  readonly ContentDisposition: "Content-Disposition";
+  /** Specifies the character encodings that are acceptable. */
+  readonly AcceptEncoding: "Accept-Encoding";
+  /** Informs the server about the types of data that can be sent back. */
+  readonly Accept: "Accept";
+  /** Contains the credentials to authenticate with the server. */
+  readonly Authorization: "Authorization";
+  /** The user agent string of the client software. */
+  readonly UserAgent: "User-Agent";
+  /** The domain name of the server and port number. */
+  readonly Host: "Host";
+  /** The address of the previous web page from which the current request originated. */
+  readonly Referer: "Referer";
+  /** Indicates whether the connection should be kept alive. */
+  readonly Connection: "Connection";
+  /** Requests that the server switch to a different protocol (e.g. WebSocket). */
+  readonly Upgrade: "Upgrade";
+  /** Used to specify directives that must be obeyed by caching mechanisms. */
+  readonly Pragma: "Pragma";
+  /** The date and time at which the message was sent. */
+  readonly Date: "Date";
+  /** Makes the request conditional based on the ETag of the resource. */
+  readonly IfNoneMatch: "If-None-Match";
+  /** Makes the request conditional based on the last modification date. */
+  readonly IfModifiedSince: "If-Modified-Since";
+  /** An identifier for a specific version of a resource. */
+  readonly ETag: "ETag";
+  /** The date and time after which the response is considered stale. */
+  readonly Expires: "Expires";
+  /** The last modification date of the resource. */
+  readonly LastModified: "Last-Modified";
+  /** Indicates the URL to redirect a page to. */
+  readonly Location: "Location";
+  /** Defines the authentication method that should be used. */
+  readonly WWWAuthenticate: "WWW-Authenticate";
+  /** Determines how long the results of a preflight request can be cached. */
+  readonly AccessControlMaxAge: "Access-Control-Max-Age";
+  /** Indicates whether the response can be shared with resources with credentials. */
+  readonly AccessControlAllowCredentials: "Access-Control-Allow-Credentials";
+  /** Indicates which HTTP method will be used in the actual CORS request. */
+  readonly AccessControlRequestMethod: "Access-Control-Request-Method";
+  /** Indicates which headers can be exposed to the browser in a CORS response. */
+  readonly AccessControlExposeHeaders: "Access-Control-Expose-Headers";
+  /** Indicates which origins are allowed to access the resource. */
+  readonly AccessControlAllowOrigin: "Access-Control-Allow-Origin";
+  /** Specifies the HTTP methods allowed when accessing the resource in a CORS request. */
+  readonly AccessControlAllowMethods: "Access-Control-Allow-Methods";
+  /** Specifies the HTTP headers allowed in a CORS request. */
+  readonly AccessControlAllowHeaders: "Access-Control-Allow-Headers";
+  /** Sends cookies from the server to the client. */
+  readonly SetCookie: "Set-Cookie";
+  /** Sends cookies from the client to the server. */
+  readonly Cookie: "Cookie";
+  /** Determines which headers should be used to select a response from cache when content negotiation is in use. */
+  readonly Vary: "Vary";
+  /** Set to "nosniff" by default in {@link Res}. */
+  readonly XContentTypeOptions: "X-Content-Type-Options";
+};
+/**
+ * A header name. The {@link HeaderKey} constants are suggested, but
+ * {@link OrString} keeps any custom header name assignable — the enum is a
+ * convenience, not a restriction.
+ */
+type HeaderKey = OrString$1<ValueOf<typeof HeaderKey>>;
+/**
+ * A caching policy, rendered into a `Cache-Control` value by
+ * {@link createCacheControlHeader}. Used by {@link FileRoute.cache} and by each
+ * entry of a {@link BundleRouteDefinition}.
+ */
+interface CacheControlDefinition {
+  /** Allows shared caches — proxies and CDNs — to store the response, not just the browser. */
+  public?: boolean;
+  /** How long the response stays fresh, in seconds. */
+  maxAge?: number;
+  /** Promises the response will never change, so the browser skips revalidation entirely. Only meaningful with a content hash in the URL. */
+  immutable?: boolean;
+  /** Caches the response but revalidates before every use. Overrides the other directives except `noStore`. */
+  noCache?: boolean;
+  /** Forbids storing the response anywhere. Overrides every other directive. */
+  noStore?: boolean;
+}
+/**
+ * How a response body should be presented, rendered by
+ * {@link createContentDispositionHeader}.
+ */
+interface ContentDispositionDefinition {
+  /** `"inline"` to display in the browser, `"attachment"` to prompt a download. */
+  disposition: "attachment" | "inline";
+  /** The name to save the file under. Omit it to let the client decide. */
+  filename?: string;
+}
+declare global {
+  /**
+   * The `Headers` surface after {@link patchGlobalHeaders} has run.
+   *
+   * The existing methods are re-declared to accept a {@link HeaderKey} and a
+   * {@link HeadersInitValue}; the rest are additions.
+   */
+  interface Headers {
+    /** Adds a value without replacing existing ones. An array appends each item as its own header line. */
+    append(name: HeaderKey, value: MaybeArray<HeadersInitValue>): void;
+    /** Sets a header, replacing any existing value. Numbers and booleans are stringified. */
+    set(name: HeaderKey, value: HeadersInitValue): void;
+    /** Reads a header, falling back to the lowercased name. */
+    get(name: HeaderKey): Nullable<string>;
+    /** Reports whether a header is present, falling back to the lowercased name. */
+    has(name: HeaderKey): boolean;
+    /** Sets many headers at once. See {@link CustomHeadersInit}. */
+    setMany(init: CustomHeadersInit): void;
+    /** Sets `Cache-Control` from a {@link CacheControlDefinition}. */
+    setCacheControl(def: CacheControlDefinition): void;
+    /** Sets `Content-Disposition` from a {@link ContentDispositionDefinition}. */
+    setContentDisposition(def: ContentDispositionDefinition): void;
+  }
+}
+//#endregion
+//#region ../corpus/dist/XFile/index.d.ts
+/**
+ * A file at a path.
+ *
+ * The path is the only state; nothing is read at construction, so an XFile
+ * doesn't officially exist (get it?) and can be written from scratch.
+ * The path-manipulation members — {@link XFile.name}, {@link XFile.extension},
+ * {@link XFile.sibling} — are pure string work and never touch the disk.
+ *
+ * Reads are synchronous. The routes that use it read either once at startup or
+ * per request from the OS page cache, so the simpler API is worth more than the
+ * async one.
+ */
+declare class XFile {
+  /** Fallback extension for extension-less files, defaults to "txt" */
+  private readonly fallbackExtension;
+  /**
+   * Creates a file handle. Nothing is read or checked until an operation asks
+   * for it.
+   *
+   * @param pathOrBunFile - The path of the file or BunFile directly.
+   * @param fallbackExtension - Fallback extension for extension-less files,
+   * defaults to "txt". It decides what {@link XFile.mimeType} reports for a file
+   * whose name carries no extension.
+   */
+  constructor(
+  /** The path of the file or BunFile directly. */
+  pathOrBunFile: string | Bun.BunFile,
+  /** Fallback extension for extension-less files, defaults to "txt" */
+  fallbackExtension?: string);
+  /** The underlying Bun file, used for streaming. */
+  readonly bunFile: Bun.BunFile;
+  /** The path this handle points at, as given. */
+  readonly path: string;
+  /** Matches either path separator, so paths split correctly on any platform. */
+  private readonly SEP;
+  /** The extension separator. */
+  private readonly DOT;
+  /** The empty string, used as a join separator and a replacement target. */
+  private readonly EMPTY;
+  /**
+   * Joins parts with no separator.
+   *
+   * @param parts - The strings to concatenate.
+   * @returns The joined string.
+   */
+  private readonly concat;
+  /**
+   * Reads the file content and returns it as a string.
+   * @param encoding defaults to "utf8"
+   * @returns The decoded contents.
+   * @throws {@link Error} when the file does not exist.
+   */
+  text(encoding?: BufferEncoding): string;
+  /**
+   * Opens a readable stream to the file's content.
+   *
+   * @returns The stream. This is what the file-serving routes return for large
+   * bodies, so nothing is buffered in memory.
+   */
+  stream(): ReadableStream<Uint8Array>;
+  /**
+   * Checks if the file exists in the file system.
+   *
+   * Deliberately uses Node's `fs` rather than Bun's: `Bun.file().exists()`
+   * caches, and this handle's `BunFile` was created before the file may have
+   * been deleted, so it would report a stale answer.
+   *
+   * @returns `true` when the file exists right now.
+   */
+  exists(): boolean;
+  /**
+   * Writes to the file, directories are created recursively.
+   *
+   * @param data - The contents to write, replacing anything already there.
+   */
+  write(data: string | ArrayBuffer | Uint8Array): void;
+  /**
+   * Deletes the file.
+   *
+   * @throws {@link Error} when the file does not exist.
+   */
+  unlink(): void;
+  /**
+   * Reads the file content and returns it as a Uint8Array.
+   *
+   * @returns The raw bytes. Used where an exact `Content-Length` is wanted; see
+   * {@link XFile.stream} for the alternative.
+   * @throws {@link Error} when the file does not exist.
+   */
+  bytes(): Buffer<ArrayBuffer>;
+  /**
+   * Returns file metadata (size, dates, etc.)
+   *
+   * @returns The stats.
+   * @throws {@link Error} when the file does not exist.
+   */
+  stat(): fs.Stats;
+  /**
+   * Returns the file size in bytes, or null if the file doesn't exist. Unlike
+   * {@link XFile.stat}, a missing file is not an error here.
+   *
+   * @returns The size in bytes, or `null`.
+   */
+  size(): number | null;
+  /**
+   * Copies the file to a destination path, creating directories recursively.
+   *
+   * @param dest - Where to copy it.
+   * @returns A handle to the copy, carrying this handle's fallback extension.
+   */
+  copyTo(dest: string): XFile;
+  /**
+   * Moves (renames) the file to a destination path, creating directories recursively.
+   *
+   * @param dest - Where to move it.
+   * @returns A handle to the new location. This handle still points at the old
+   * path, which no longer exists.
+   */
+  moveTo(dest: string): XFile;
+  /**
+   * Appends data to the file.
+   *
+   * @param data - The contents to add at the end. Unlike {@link XFile.write},
+   * parent directories are not created.
+   */
+  append(data: string | Uint8Array): void;
+  /**
+   * Returns a new XFile pointing to a sibling path (same directory, different name).
+   *
+   * @param filename - The sibling's full name, extension included.
+   * @returns A handle to the sibling. Nothing is created on disk.
+   */
+  sibling(filename: string): XFile;
+  /**
+   * Returns a new XFile with a different extension.
+   *
+   * @param ext - The new extension, without the leading dot.
+   * @returns A handle to the renamed path. Nothing is moved on disk.
+   */
+  withExtension(ext: string): XFile;
+  /**
+   * The absolute directory path containing this file.
+   *
+   * @returns The directory path.
+   */
+  get dir(): string;
+  /**
+   * The name of the file without the extension.
+   *
+   * @returns The bare name.
+   */
+  get name(): string;
+  /**
+   * The file extension (e.g., "html", "md"), excluding the leading dot.
+   *
+   * @returns The lowercased extension, or the fallback extension when the name
+   * has none.
+   */
+  get extension(): string;
+  /**
+   * The full name of the file, including the extension.
+   *
+   * @returns The name with its extension. This is what the file-serving routes
+   * send as the `Content-Disposition` filename.
+   */
+  get fullname(): string;
+  /**
+   * Gets the parent directory names as an array, ordered from the immediate parent up to the root.
+   *
+   * @returns The directory names, nearest first. Empty segments are dropped, so
+   * a leading or doubled separator does not produce blanks.
+   */
+  get parentDirs(): string[];
+  /**
+   * The standard MIME type associated with the file's extension.
+   *
+   * Resolved from the extension alone — the file's contents are never read, and
+   * it need not exist. Any parameters such as `charset` are stripped, so the
+   * result is safe to use as a bare `Content-Type`.
+   *
+   * @returns The MIME type, or `"application/octet-stream"` when the extension
+   * maps to nothing known.
+   */
+  get mimeType(): string;
+}
+//#endregion
+//#region ../corpus/dist/Res/index.d.ts
+/**
+ * Produces the events for a server-sent event stream, used by {@link Res.sse}.
+ *
+ * @param send - Emits one event. `data` is JSON-serialized; `event` names the
+ * event type for a client listening on something other than `message`, and `id`
+ * lets a client resume from where it left off.
+ * @returns Nothing when the source is finite — the stream is closed for you once
+ * it resolves — or a cleanup function when it is open-ended, in which case the
+ * stream stays open and the function runs if the client disconnects.
+ */
+type SseSource = (send: (item: {
+  data: unknown;
+  event?: string;
+  id?: string;
+}) => void) => MaybePromise<void | (() => void)>;
+/**
+ * Produces the lines for a newline-delimited JSON stream, used by
+ * {@link Res.ndjson}.
+ *
+ * @param send - Emits one item, JSON-serialized on its own line.
+ * @returns Nothing to close the stream when the source resolves, or a cleanup
+ * function to keep it open and be told when the client disconnects.
+ */
+type NdjsonSource = (send: (item: unknown) => void) => MaybePromise<void | (() => void)>;
+/** A `ResponseInit` that can also carry cookies. */
+interface ResInit extends ResponseInit {
+  /** Cookies to seed {@link Res.cookies} with. */
+  cookies?: Cookies;
+}
+/**
+ * A response under construction.
+ *
+ * Everything is mutable until {@link Res.toNativeResponse} is called, so a
+ * {@link Middleware} can adjust a response a route handler already built. The
+ * body is kept as the original value rather than serialized eagerly, which is
+ * what lets the content type be inferred from it at the very end.
+ *
+ * Headers and cookies are both lazy, so an untouched response allocates neither.
+ * The chainable methods — {@link Res.file}, {@link Res.redirect},
+ * {@link Res.sse} and the rest — set the body and its headers together and
+ * return `this`.
+ *
+ * @typeParam R - The body type, carried from the route's own response type.
+ */
+declare class Res<R = unknown> {
+  /**
+   * Creates a response.
+   *
+   * @param body - The body value. Serialized by {@link resolveResBody} at
+   * {@link Res.toNativeResponse} time, not now.
+   * @param init - Status, status text, headers and cookies. See
+   * {@link ResInit}.
+   */
+  constructor(body?: Nullable<BodyInit | R>, init?: ResInit);
+  /**
+   * The body to send. Assign any value — objects become JSON, typed arrays stay
+   * binary, streams pass through — and {@link resolveResBody} works out the rest
+   * at serialization time.
+   */
+  body: Nullable<BodyInit | R>;
+  /** The status code. Defaults to {@link Status.OK}. */
+  status: number;
+  /** The status text. Empty by default, which lets the runtime supply the standard phrase. */
+  statusText: string;
+  /** Backing store for {@link Res.headers}, created on first access. */
+  private _headers;
+  /**
+   * The response headers.
+   *
+   * Reading them rewrites the `Set-Cookie` lines from {@link Res.cookies} first,
+   * so the two views never disagree — and writing `Set-Cookie` here feeds back
+   * into the cookie map. Values may be numbers or booleans, since
+   * {@link patchGlobalHeaders} has stringified setters.
+   *
+   * @returns The headers, created on first access.
+   */
+  get headers(): Headers;
+  /** Backing store for {@link Res.cookies}, created on first access. */
+  private _cookies;
+  /**
+   * The cookies to send, as a mutable map.
+   *
+   * This is the authoritative view: the map is serialized into `Set-Cookie`
+   * whenever {@link Res.headers} is read, so deleting a cookie here removes its
+   * header. Values are percent-encoded on serialization, which is what keeps a
+   * CRLF in a cookie value from splitting the response.
+   *
+   * @returns The {@link Cookies} map, created on first access.
+   */
+  get cookies(): Cookies;
+  /**
+   * Serializes everything into a native `Response`.
+   *
+   * The content type inferred from the body is applied only when none was set
+   * explicitly, so a handler's own choice always wins. `X-Content-Type-Options:
+   * nosniff` is set unconditionally — without it a browser will sniff a
+   * `text/plain` body that looks like markup and render it as HTML, turning any
+   * reflected value into XSS.
+   *
+   * @returns The response to send over the wire. Called by
+   * {@link App.respond}.
+   */
+  toNativeResponse(): Response;
+  /**
+   * Turns the response into a server-sent event stream.
+   *
+   * Sets the body to a stream and the headers browsers require for `EventSource`
+   * to work — the event stream type, no caching, and a kept-alive connection.
+   *
+   * @param source - The {@link SseSource} producing events. Return a cleanup
+   * function from it to keep the stream open indefinitely.
+   * @param retry - Reconnection delay in milliseconds, sent with every event to
+   * tell the client how long to wait before reconnecting.
+   * @returns This response, for chaining.
+   */
+  sse(source: SseSource, retry?: number): this;
+  /**
+   * Turns the response into a newline-delimited JSON stream.
+   *
+   * Each item is serialized onto its own line, so a client can parse results as
+   * they arrive instead of waiting for a whole array. Useful for large result
+   * sets and progressive output where the event semantics of {@link Res.sse} are
+   * not needed.
+   *
+   * @param source - The {@link NdjsonSource} producing items. Return a cleanup
+   * function from it to keep the stream open indefinitely.
+   * @returns This response, for chaining.
+   */
+  ndjson(source: NdjsonSource): this;
+  /**
+   * Streams a file as the response body, without reading it into memory. Prefer
+   * this over {@link Res.file} for anything large.
+   *
+   * @param fileOrPath - An {@link XFile} or a path to one.
+   * @param disposition - `"inline"` to display in the browser, `"attachment"` to
+   * prompt a download under the file's own name.
+   * @returns This response, for chaining.
+   * @throws {@link Exception} with {@link Status.NOT_FOUND} when the file does
+   * not exist.
+   */
+  streamFile(fileOrPath: XFile | string, disposition: ContentDispositionDefinition["disposition"]): this;
+  /**
+   * Sends a file as the response body, read into memory so it can carry an exact
+   * `Content-Length`. Use {@link Res.streamFile} instead for large files.
+   *
+   * @param fileOrPath - An {@link XFile} or a path to one.
+   * @returns This response, for chaining.
+   * @throws {@link Exception} with {@link Status.NOT_FOUND} when the file does
+   * not exist.
+   */
+  file(fileOrPath: XFile | string): this;
+  /**
+   * Redirects the client to another URL.
+   *
+   * @param url - Where to send the client, absolute or relative.
+   * @param status - Which redirect to use. Defaults to {@link Status.FOUND}, a
+   * temporary redirect that browsers do not cache. See
+   * {@link Res.permanentRedirect}, {@link Res.temporaryRedirect} and
+   * {@link Res.seeOther} for the named alternatives.
+   * @returns This response, for chaining.
+   */
+  redirect(url: string | URL, status?: 301 | 302 | 303 | 307 | 308): this;
+  /**
+   * Redirects with {@link Status.MOVED_PERMANENTLY}, which browsers and search
+   * engines cache indefinitely. Use it only when the resource has really moved
+   * for good.
+   *
+   * @param url - Where to send the client.
+   * @returns This response, for chaining.
+   */
+  permanentRedirect(url: string | URL): this;
+  /**
+   * Redirects with {@link Status.TEMPORARY_REDIRECT}, which preserves the
+   * original method and body — unlike {@link Status.FOUND}, which clients
+   * commonly turn into a GET.
+   *
+   * @param url - Where to send the client.
+   * @returns This response, for chaining.
+   */
+  temporaryRedirect(url: string | URL): this;
+  /**
+   * Redirects with {@link Status.SEE_OTHER}, which explicitly switches the
+   * client to a GET. This is the correct redirect after a successful POST, since
+   * it stops a refresh from resubmitting the form.
+   *
+   * @param url - Where to send the client.
+   * @returns This response, for chaining.
+   */
+  seeOther(url: string | URL): this;
+}
+//#endregion
+//#region ../corpus/dist/Request/index.d.ts
+/** Commonly used HTTP verbs. See [MDN Reference](https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Methods) for the full spec. */
+declare const Method: {
+  /** Retrieve a resource from the server. */
+  readonly GET: "GET";
+  /** Submit data to create a new resource. */
+  readonly POST: "POST";
+  /** Replace an entire resource with new data. */
+  readonly PUT: "PUT";
+  /** Apply partial modifications to a resource. */
+  readonly PATCH: "PATCH";
+  /** Remove a resource from the server. */
+  readonly DELETE: "DELETE";
+  /** Get response headers without body. */
+  readonly HEAD: "HEAD";
+  /** Discover communication options. */
+  readonly OPTIONS: "OPTIONS";
+  /** Establish tunnel to server. */
+  readonly CONNECT: "CONNECT";
+  /** Echo back received request. */
+  readonly TRACE: "TRACE";
+};
+/**
+ * An HTTP method. The {@link Method} constants are suggested, but
+ * {@link OrString} keeps any custom verb assignable.
+ */
+type Method = OrString$1<ValueOf<typeof Method>>;
+declare global {
+  interface RequestInit {
+    /**
+     * Cookies to seed the request with. Anything in the `Cookie` header is
+     * layered on top of these.
+     */
+    cookies?: Cookies;
+  }
+  /** The `Request` surface after {@link patchGlobalRequest} has run. */
+  interface Request {
+    /**
+     * The raw path parameters matched by the route, populated by Bun's router.
+     * {@link Context.params} holds the parsed, validated version.
+     */
+    params: {
+      [x: string]: string;
+    };
+    /** The request's cookies, parsed from the `Cookie` header on first access. */
+    cookies: Cookies;
+  }
+}
+//#endregion
+//#region ../corpus/dist/ParserBase/SchemaParser/index.d.ts
+/**
+ * Any Standard Schema validator producing `T`. This is the type
+ * {@link RouteConfig} fields accept.
+ *
+ * @typeParam T - What the schema validates to.
+ */
+type Schema<T = unknown> = StandardSchemaV1<unknown, T>;
+//#endregion
+//#region ../corpus/dist/RouteBase/index.d.ts
+/**
+ * What kind of route this is. {@link App.composeRoutes} branches on it — a
+ * `websocket` route upgrades instead of responding, and a `bundle` route is
+ * excluded from {@link RateLimiter} by default.
+ */
+declare const RouteVariant: {
+  /** A file whose contents feed a handler. See {@link StaticRoute}. */
+  readonly static: "static";
+  /** A single file served as-is. See {@link FileRoute}. */
+  readonly file: "file";
+  /** A handler function. See {@link Route}. */
+  readonly dynamic: "dynamic";
+  /** A connection upgrade. See {@link WebSocketRoute}. */
+  readonly websocket: "websocket";
+  /** A directory of built files. See {@link BundleRoute}. */
+  readonly bundle: "bundle";
+};
+/** One of the {@link RouteVariant} values. */
+type RouteVariant = ValueOf<typeof RouteVariant>;
+/**
+ * The request to simulate when calling a route directly through
+ * {@link RouteBase.handle}. Every field is optional — supply only what the
+ * handler reads.
+ *
+ * @typeParam B - Body type.
+ * @typeParam S - Search type.
+ * @typeParam P - Params type.
+ */
+type RouteHandleInput<B, S, P> = {
+  /** The request body, already in parsed form. */
+  body?: B;
+  /** The query values, already in parsed form. */
+  search?: S;
+  /** The path parameters, which are also substituted into the endpoint. */
+  params?: P;
+  /** Headers for the synthesized request. */
+  headers?: HeadersInit;
+};
+/**
+ * A route's schemas and per-route limits.
+ *
+ * The schemas do double duty: {@link SchemaParser} validates against them at
+ * request time, and their inferred output types become the {@link Context}
+ * types the handler sees. {@link getContextAccess} also reads this to decide
+ * what to parse — a surface with a schema is always parsed, since it must be
+ * validated.
+ *
+ * @typeParam B - Body type.
+ * @typeParam S - Search type.
+ * @typeParam P - Params type.
+ * @typeParam R - Response type.
+ */
+type RouteConfig<B = unknown, S = unknown, P = unknown, R = unknown> = {
+  /**
+   * Body size ceiling in bytes for this route, enforced by
+   * {@link enforceBodyLimit}. Tightens {@link App.maxRequestBodySize} for a
+   * single endpoint — an upload route and a JSON route rarely want the same
+   * limit.
+   */
+  maxRequestBodySize?: number;
+  /** Schema for the response body. Types the handler's return value. */
+  response?: Schema<R>;
+  /** Schema for the request body. Validated before the handler runs. */
+  body?: Schema<B>;
+  /** Schema for the query string. Validated before the handler runs. */
+  search?: Schema<S>;
+  /** Schema for the path parameters. Validated before the handler runs. */
+  params?: Schema<P>;
+};
+/**
+ * The contract every route kind implements.
+ *
+ * Subclasses declare what they are and how they answer; this class supplies
+ * {@link RouteBase.id}, registration, and the direct-invocation helpers.
+ *
+ * The abstract members exist because {@link App} reads them while compiling —
+ * {@link RouteBase.variant} decides the pipeline shape,
+ * {@link RouteBase.config} decides what gets parsed and validated, and the rest
+ * decide where the route sits in the route map.
+ *
+ * @typeParam B - Parsed {@link Context.body} type.
+ * @typeParam S - Parsed {@link Context.search} type.
+ * @typeParam P - Parsed {@link Context.params} type.
+ * @typeParam R - Response body type.
+ * @typeParam E - The literal endpoint type.
+ */
+declare abstract class RouteBase<B = any, S = any, P = any, R = any, E extends string = string> {
+  /** Which kind of route this is. */
+  abstract readonly variant: RouteVariant;
+  /** The HTTP method this route answers. */
+  abstract readonly method: Method;
+  /** The path this route answers, before {@link App.prefix} is applied. */
+  abstract readonly endpoint: E;
+  /** Schemas and limits for this route, if any. */
+  abstract readonly config?: RouteConfig<B, S, P, R>;
+  /**
+   * Answers the request. Declared as a method rather than a property so
+   * subclasses can narrow its parameter types — a property declaration would
+   * make the variance error out on routes that take `never` for their inputs.
+   *
+   * @param args - The {@link ContextHandler} arguments: the {@link Context} for
+   * the request.
+   * @returns The response body, a {@link Res}, or nothing.
+   */
+  abstract handler(...args: Parameters<ContextHandler<B, S, P, R>>): ReturnType<ContextHandler<B, S, P, R>>;
+  /**
+   * The route's identity, as `"METHOD /endpoint"`.
+   *
+   * This is what {@link Middleware.useOn} targets and what
+   * {@link Controller.routeIds} collects, so two routes sharing a method and
+   * endpoint share middlewares as well.
+   *
+   * @returns The id.
+   */
+  get id(): string;
+  /**
+   * Appends this route to the nearest {@link App}. Called by every concrete
+   * route's constructor; a subclass that declares its members as class fields
+   * must call it itself, after those fields are initialized.
+   */
+  register(): void;
+  /**
+   * Invokes the route's handler directly, with no server and no HTTP.
+   *
+   * The inputs are taken as already-parsed values, so nothing is decoded or
+   * validated — and no {@link Middleware} runs, since middlewares are folded in
+   * by {@link App} at compile time, not by the route. What this exercises is the
+   * handler itself, which is what makes it useful for unit tests and for calling
+   * one route's logic from another.
+   *
+   * @param data - The {@link RouteHandleInput} to build the {@link Context}
+   * from.
+   * @returns Whatever the handler returns.
+   */
+  handle(data: RouteHandleInput<B, S, P>): MaybePromise<R>;
+  /**
+   * Builds the request a {@link RouteHandleInput} describes, so the
+   * {@link Context} that {@link RouteBase.handle} creates has a real request
+   * behind it — a handler reading {@link Context.url} or a header gets what it
+   * would have got over the wire.
+   *
+   * Params are substituted into the endpoint, so `/users/:id` becomes a concrete
+   * URL. A `FormData` body is passed through untouched, since the runtime sets
+   * its own multipart content type with the boundary; anything else is
+   * JSON-encoded.
+   *
+   * @param data - The {@link RouteHandleInput} to build from.
+   * @returns The synthesized request, addressed against {@link App.baseUrl}.
+   */
+  request(data: RouteHandleInput<B, S, P>): Request;
+}
+//#endregion
+//#region ../corpus/dist/RouteBase/WebSocketRoute/index.d.ts
+/**
+ * Runs once a connection has been upgraded and is ready.
+ *
+ * @param ws - The newly opened {@link ServerWebSocket}.
+ */
+type WebSocketOnOpen = (ws: ServerWebSocket) => MaybePromise<void>;
+/**
+ * Runs when a connection closes, whichever side ended it.
+ *
+ * @param ws - The closing {@link ServerWebSocket}.
+ * @param code - The WebSocket close code, when one was sent.
+ * @param reason - The accompanying reason, when one was sent.
+ */
+type WebSocketOnClose = (ws: ServerWebSocket, code?: number, reason?: string) => MaybePromise<void>;
+/**
+ * Runs for each message a client sends.
+ *
+ * @param ws - The {@link ServerWebSocket} the message arrived on.
+ * @param message - The payload: a string for text frames, a `Buffer` for binary
+ * ones.
+ */
+type WebSocketOnMessage = (ws: ServerWebSocket, message: string | Buffer) => MaybePromise<void>;
+/** The socket lifecycle callbacks a {@link WebSocketRoute} is built from. */
+interface WebSocketRouteDefinition {
+  /** Called once per connection, after the upgrade succeeds. */
+  onOpen?: WebSocketOnOpen;
+  /** Called once per connection, when it closes. */
+  onClose?: WebSocketOnClose;
+  /** Called for every message received. The only required callback — a socket that never reads has nothing to do. */
+  onMessage: WebSocketOnMessage;
+}
+/**
+ * A WebSocket endpoint.
+ *
+ * Constructing one registers it on the nearest {@link App}, which upgrades
+ * matching requests rather than responding to them. The callbacks are shared by
+ * every connection to the endpoint, and each event receives the socket it
+ * concerns.
+ *
+ * @typeParam E - The literal endpoint type, carried so the endpoint stays
+ * narrowly typed at the call site.
+ */
+declare class WebSocketRoute<E extends string = string> extends RouteBase<never, never, never, WebSocketRoute, E> {
+  /**
+   * Creates a websocket route for subclasses, which declare
+   * {@link WebSocketRoute.endpoint} and the callbacks as class fields and call
+   * {@link RouteBase.register} themselves.
+   */
+  constructor();
+  /**
+   * Creates a websocket route and registers it on the nearest {@link App}.
+   *
+   * @param endpoint - The path clients connect to.
+   * @param definition - The {@link WebSocketRouteDefinition} holding the socket
+   * lifecycle callbacks.
+   */
+  constructor(endpoint: E, definition: WebSocketRouteDefinition);
+  /**
+   * Marks this route as {@link RouteVariant.websocket}, which is what tells
+   * {@link App.composeRoutes} to upgrade rather than respond.
+   */
+  readonly variant: RouteVariant;
+  /** Always {@link Method.GET} — an upgrade handshake is a GET request. */
+  readonly method: Method;
+  /** The path clients connect to. */
+  endpoint: E;
+  /** No schemas apply: an upgrade request carries no body, search or params to validate. */
+  readonly config?: RouteConfig<never, never, never, WebSocketRoute<string>> | undefined;
+  /**
+   * Returns the route itself, which {@link App.composeRoutes} attaches to the
+   * socket as its data — that is how a message arriving minutes later finds its
+   * way back to {@link WebSocketRoute.onMessage}.
+   *
+   * The upgrade itself still happens in {@link App}; this handler only supplies
+   * what the socket carries.
+   *
+   * @returns This route.
+   */
+  readonly handler: ContextHandler<never, never, never, WebSocketRoute<string>>;
+  /** Called once per connection, after the upgrade succeeds. */
+  onOpen?: WebSocketOnOpen | undefined;
+  /** Called once per connection, when it closes. */
+  onClose?: WebSocketOnClose | undefined;
+  /** Called for every message received. */
+  onMessage: WebSocketOnMessage;
+}
+//#endregion
+//#region ../corpus/dist/Server/index.d.ts
+/**
+ * A live WebSocket connection. Its `data` is the {@link WebSocketRoute} that
+ * accepted the upgrade, which is what {@link App.createServer} dispatches the
+ * open, message and close events through.
+ */
+type ServerWebSocket = Bun.ServerWebSocket<WebSocketRoute>;
+/** The running Bun server, as held by {@link App.server}. */
+type Server = Bun.Server<WebSocketRoute>;
+//#endregion
+//#region ../corpus/dist/Context/index.d.ts
+/**
+ * Declaration target for {@link Context.data}, the request-scoped state shared
+ * between {@link Middleware} and route handlers.
+ *
+ * Empty by design. Augment it from your own code so everything a middleware sets
+ * is typed where a handler reads it:
+ *
+ * ```ts
+ * declare module "@ozanarslan/corpus" {
+ *   interface ContextDataInterface {
+ *     user: User;
+ *   }
+ * }
+ * ```
+ */
+interface ContextDataInterface {}
+/**
+ * A function that handles a request given its {@link Context}. This is the shape
+ * of a {@link RouteBase} handler and of the app-level hooks
+ * {@link App.handleNotFound} and {@link App.handlePreflight}.
+ *
+ * A {@link Middleware} handler is a {@link MiddlewareHandler} instead, since it
+ * additionally receives `next`.
+ *
+ * @param context - The {@link Context} for the request.
+ * @returns The response body, a {@link Res}, or a promise of either. Returning
+ * `undefined` leaves {@link Context.res} as the handler mutated it.
+ * @typeParam B - Parsed {@link Context.body} type.
+ * @typeParam S - Parsed {@link Context.search} type.
+ * @typeParam P - Parsed {@link Context.params} type.
+ * @typeParam R - Response body type.
+ */
+type ContextHandler<B = unknown, S = unknown, P = unknown, R = unknown> = (context: Context<B, S, P, R>) => MaybePromise<R>;
+/**
+ * Everything a handler needs to know about one request, and everything it uses
+ * to answer it.
+ *
+ * The type parameters are supplied by the route the context belongs to, so a
+ * handler sees its own validated shapes rather than `unknown`.
+ *
+ * {@link Context.res} and {@link Context.url} are lazy: neither the response
+ * object nor the parsed URL is constructed until something reads it, so a
+ * handler that returns a body without touching either pays for neither.
+ *
+ * The parsed containers are created with {@link createSafeObject}, so a payload
+ * carrying a `__proto__` key cannot reach `Object.prototype` through them.
+ *
+ * @typeParam B - Parsed {@link Context.body} type.
+ * @typeParam S - Parsed {@link Context.search} type.
+ * @typeParam P - Parsed {@link Context.params} type.
+ * @typeParam R - Response body type carried by {@link Context.res}.
+ */
+declare class Context<B = unknown, S = unknown, P = unknown, R = unknown> {
+  /**
+   * Creates a context with empty parsed containers; {@link App} fills them
+   * during the request lifecycle.
+   *
+   * @param req - The incoming request.
+   * @param server - The {@link Server} that accepted it. Absent when the request
+   * was dispatched without one, which is why {@link Context.server} is optional
+   * at every use site — including the WebSocket upgrade.
+   */
+  constructor(req: Request, server: Maybe<Server>);
+  /**
+   * The parsed request body, decoded by {@link BodyParser} and validated against
+   * the route's {@link RouteConfig} body schema.
+   *
+   * Empty for {@link Method.GET} and {@link Method.HEAD} requests, and for any
+   * route whose handlers never read it.
+   */
+  body: B;
+  /**
+   * The path parameters matched by the route, parsed by
+   * {@link ParsersRegistry.urlParamsParser} and validated against the route's
+   * params schema. A wildcard segment is available under the `*` key.
+   */
+  params: P;
+  /**
+   * The query string, parsed by {@link ParsersRegistry.searchParamsParser} and
+   * validated against the route's search schema. Empty when the request carried
+   * no query string.
+   */
+  search: S;
+  /**
+   * Free-form request-scoped state, shared across the whole
+   * {@link Middleware} chain and the route handler. This is how a middleware
+   * hands something — an authenticated user, a request id — to what runs after
+   * it. Type it by augmenting {@link ContextDataInterface}.
+   */
+  data: ContextDataInterface;
+  /**
+   * The {@link Server} that accepted the request. Needed to upgrade a connection
+   * to a {@link WebSocketRoute}; absent when the request was dispatched without
+   * a server.
+   */
+  readonly server: Maybe<Server>;
+  /**
+   * The untouched incoming request. Read it for headers and for the raw body;
+   * the parsed views live on {@link Context.body} and its siblings.
+   */
+  readonly req: Request;
+  /** Backing store for {@link Context.res}, constructed on first access. */
+  private _res;
+  /**
+   * The response under construction. Mutate it to set status, headers or body
+   * before returning, or assign a whole new {@link Res} to replace it.
+   *
+   * A {@link Middleware} that replaces this after `next()` resolves wins over
+   * whatever the downstream handler returned — see {@link composeHandlerChain}.
+   *
+   * @returns The response object, created on first access.
+   */
+  get res(): Res<R>;
+  set res(value: Res<R>);
+  /** Backing store for {@link Context.url}, parsed on first access. */
+  private _url;
+  /**
+   * The request URL, parsed once and reused.
+   *
+   * @returns The parsed `URL`. Prefer {@link Context.params} and
+   * {@link Context.search} for path and query values; reach for this when you
+   * need the pathname or origin itself, as {@link BundleRoute} does.
+   */
+  get url(): URL;
+}
+//#endregion
+//#region ../utils/is.d.ts
+type OrString<T> = T | (string & {});
+//#endregion
+//#region src/Importable/index.d.ts
+type ImportableKind = OrString<"model" | "service" | "controller" | "route" | "exception">;
+//#endregion
+//#region src/Config/Config.d.ts
+interface ApiClientConfig {
+  /**
+   * Disables api client generation.
+   * Types and models are still generated.
+   *
+   * @default false
+   */
+  disabled: boolean;
+  /**
+   * Controls how the API Client is exported.
+   * Set to false if you don't want the api client.
+   *
+   * @default "CorpusApi"
+   */
+  exportAs: OrString<"CorpusApi">;
+  /**
+   * Makes all API Client methods and properties static.
+   *
+   * @default false
+   */
+  useStaticClass: boolean;
+}
+interface DefaultMethodsConfig {
+  get: {
+    propertyKey: OrString<"get">;
+    address: `${Method} /${string}`;
+  };
+  getByParams: {
+    propertyKey: OrString<"getByParams">;
+    address: `${Method} /${string}`;
+  };
+  create: {
+    propertyKey: OrString<"create">;
+    address: `${Method} /${string}`;
+  };
+  update: {
+    propertyKey: OrString<"update">;
+    address: `${Method} /${string}`;
+  };
+  remove: {
+    propertyKey: OrString<"remove">;
+    address: `${Method} /${string}`;
+  };
+}
+interface Config {
+  /**
+   * Suppress console logs.
+   *
+   * @default false
+   */
+  silent: boolean;
+  /**
+   * The server entrypoint file path.
+   * This file should contain your instances and the listen call.
+   *
+   * @default "./src/main.ts"
+   */
+  main: string;
+  /**
+   * The corpus package path.
+   *
+   * @default "@ozanarslan/corpus"
+   */
+  pkgPath: string;
+  /**
+   * Casing for file and directory names,
+   *
+   * @default "pascal"
+   */
+  casing: "pascal" | "camel" | "kebab";
+  /**
+   * Validation Library to generate models using.
+   * Append version number with @ if you need a specific version.
+   *
+   * Default versions:
+   * arktype: "2.2.0"
+   * yup: "1.7.1"
+   * zod: "4.3.6"
+   *
+   * @default null
+   */
+  validationLibrary: "arktype" | "zod" | "yup" | null;
+  /**
+   * The file path where the generated output will be written.
+   *
+   * @default "./src/corpus.gen.ts"
+   */
+  output: string;
+  /**
+   * Api Client specific configuration
+   */
+  apiClient: ApiClientConfig;
+  /**
+   * Collects all models to a namespace.
+   *
+   * @default true
+   */
+  exportModelsNamespace: boolean;
+  /**
+   * Collects all args to a namespace.
+   * Args are models without the response.
+   *
+   * @default true
+   */
+  exportArgsNamespace: boolean;
+  /**
+   * Generated method/type names ignore the global prefix by default,
+   * you can optionally include it.
+   *
+   * @default true
+   */
+  ignoreGlobalPrefix: boolean;
+  /**
+   * Default method names for the add modules.
+   * Used for model, service, and controllers.
+   * Map the default name to your custom one.
+   */
+  defaultMethods: DefaultMethodsConfig;
+  /**
+   * Custom output path templates per file kind, letting you control your own folder structure.
+   *
+   * Each template is a relative path string that supports the following placeholders:
+   * - `{resource}` — the resource name (e.g. `"user"`), cased per the `casing` option.
+   * - `{kind}` — the file kind (e.g. `"service"`, `"model"`, `"controller"`, `"route"`), cased per the `casing` option.
+   *
+   * Kinds without a matching entry fall back to the default template.
+   * The file extension is preserved as-is and not affected by casing.
+   *
+   * @default "{resource}/{resource}-{kind}.ts" (applied per kind when no override is set)*
+   *
+   *
+   * @example
+   * // group files by kind instead of by resource
+   * {
+   *   model: "models/{resource}-model.ts",
+   *   service: "services/{resource}-service.ts",
+   *   controller: "controllers/{resource}-controller.ts",
+   * }
+   */
+  folderStructure: Partial<Record<ImportableKind, `${string}.ts`>>;
+}
+//#endregion
+//#region ../utils/object.d.ts
+type DeepPartial<T> = T extends object ? { [K in keyof T]?: DeepPartial<T[K]>; } : T;
+declare global {
+  interface ObjectConstructor {
+    keys<O extends object>(o: O): Array<keyof O>;
+    values<O extends object>(o: O): Array<O[keyof O]>;
+    entries<O extends object>(o: O): Array<[keyof O, O[keyof O]]>;
+  }
+}
+//#endregion
+//#region src/Config/defineConfig.d.ts
+declare function defineConfig(config: DeepPartial<Config>): Config;
+//#endregion
+//#region src/exports/generateApiClient.d.ts
+declare function generateApiClient(prefix: string, routesArr: Array<RouteBase>, config: Config): void;
+//#endregion
+export { Config, DefaultMethodsConfig, defineConfig, generateApiClient };