@boon4681/giri 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 boon4681,Passwich Thongruang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,231 @@
+# Giri
+
+A stupid attempt from a stupid man who lack of foresight trying to make a backend framework.
+
+<img width="128" src="https://raw.githubusercontent.com/boon4681/giri/refs/heads/main/.image/logo.png" />
+
+## F*CK NPM PUBLISH i have to change this package name from `guri` to `giri` to `@boon4681/giri`  because of the name collision and there is no contact about request a package name that hit npm stupid filter.
+
+## Why does giri exist?
+Because I can, and I am too lazy to write an OpenAPI spec. Write handlers, return values. Giri infers the OpenAPI spec from the handlers, and generates types for params and `openapi.json` from them. Runs on Hono.
+
+> Status: early and experimental. Hono is the only adapter today; the API will change.
+
+## Install
+
+```sh
+yarn add giri hono @hono/node-server zod
+```
+
+`hono`, `@hono/node-server`, `zod`, `valibot`, and `typescript` are optional peers — install
+only what you use.
+
+## Quick start
+
+```sh
+npx giri init     # scaffold giri.config.ts + src/routes + tsconfig + .gitignore
+npx giri sync     # generate .giri/ (manifest, param types, openapi.json)
+npx giri serve    # sync, then run the dev server (watches src/ and re-syncs)
+```
+
+Then hit it:
+
+```sh
+curl http://localhost:3000/
+```
+
+## Config
+
+`giri.config.ts` is declarative — it is loaded at build time, so keep it cheap and free of
+side effects (no DB drivers here; see [Lifecycle](#lifecycle)).
+
+```ts
+import { defineConfig } from "@boon4681/giri";
+import { hono } from "@boon4681/giri/adapters/hono";
+
+export default defineConfig({
+    adapter: hono(),                       // required: the backend bridge
+    server: { port: 3000, hostname: "127.0.0.1" },
+    outDir: ".giri",                       // where generated output lives
+    alias: { "$db": "./src/db.ts" },       // import aliases, also written into tsconfig
+});
+```
+
+## Routes
+
+Every URL segment is a **folder**; every HTTP verb is its own file inside it.
+
+```
+src/routes/
+  +get.ts                       -> GET    /
+  +shared.ts                    -> folder config for everything below
+  users/
+    +get.ts                     -> GET    /users
+    +post.ts                    -> POST   /users
+    [id]/
+      +get.ts                   -> GET    /users/:id
+      posts/
+        [postId]/
+          +get.ts               -> GET    /users/:id/posts/:postId
+  db.ts                         -> no '+' prefix = plain helper, ignored by the router
+```
+
+- `[id]` folder becomes the param `:id`; params nest down the path.
+- Files without a `+` prefix are not routes — colocate helpers freely.
+
+A verb file has one shape: the `handle` named export is the handler. Everything else is an
+optional named export, so the trivial case is one line and complexity is additive.
+
+```ts
+// src/routes/users/[id]/+get.ts
+import type { Handle } from "./$types";    // generated per folder; binds c.params to this path
+import { findUser } from "../../../db";
+
+export const handle: Handle = (c) => {
+    const user = findUser(c.params.id);    // c.params.id is typed as string
+    if (!user) return c.json({ message: "user not found" }, 404);
+    return c.json(user);
+};
+// inferred responses: 200 -> User, 404 -> { message: string }
+```
+
+## The context `c`
+
+Giri owns `c`, so the return type is the schema on every backend:
+
+- `c.json(data, status?)` / `c.text(text, status?)` — return value carries the status in its type.
+- `c.params` — typed from the folder path.
+- `c.req.valid("body" | "query")` — parsed, typed input (see below).
+- `c.req.header(name)`, `c.req.url`, etc.
+- `c.get(key)` / `c.set(key, value)` — per-request vars from middleware.
+- `c.app` — app-wide services from `src/main.ts` `init()` (see [Lifecycle](#lifecycle)).
+
+## Inputs
+
+Outputs are inferred; inputs are declared with a **wrapped** schema so giri gets both runtime
+validation and a JSON Schema for the doc. Wrappers live in `@boon4681/giri/validators/zod` and
+`@boon4681/giri/validators/valibot`.
+
+```ts
+// src/routes/users/+post.ts
+import { z } from "zod";
+import { zod } from "@boon4681/giri/validators/zod";
+import type { POST } from "./$types";
+
+export const body = zod.body({
+    json: z.object({ name: z.string().min(1) }),
+});
+export const query = zod.query(z.object({ page: z.coerce.number().default(1) }));
+
+export const handle: POST = (c) => {
+    const { name } = c.req.valid("body");  // typed + validated
+    return c.json({ name }, 201);
+};
+```
+
+`zod.body` can map multiple content types (`json`, `form`) dispatched on `Content-Type` at
+runtime. An unwrapped schema is rejected at build time.
+
+## Middleware
+
+Middleware use giri's `(c, next)` shape and live in two places:
+
+- **Broad:** `export const middleware` in a folder's `+shared.ts` — applies to the whole subtree.
+- **Precise:** `export const middleware` in a verb file — applies to that one verb.
+
+Use `stack(...)` instead of a plain array so injected vars keep their types and propagate to
+downstream handlers. Run order: inherited `+shared.ts` (root to leaf), then the verb's
+`middleware`, then the handler.
+
+```ts
+// src/routes/+shared.ts
+import { stack } from "@boon4681/giri";
+import type { Middleware } from "./$types";
+
+const requestId: Middleware<{ requestId: string }> = async (c, next) => {
+    c.set("requestId", c.req.header("x-request-id") ?? "example-request");
+    await next();
+};
+
+export const middleware = stack(requestId);
+// every handler below now sees c.get("requestId"): string
+```
+
+Tag a middleware with `defineMiddleware` to feed OpenAPI security automatically — a route that
+uses it shows the scheme, a public route does not.
+
+```ts
+// src/auth.ts
+import { defineMiddleware } from "@boon4681/giri";
+
+export const auth = defineMiddleware<{ userId: string }>(
+    {
+        openapi: {
+            security: [{ bearerAuth: [] }],
+            securitySchemes: { bearerAuth: { type: "http", scheme: "bearer" } },
+        },
+    },
+    async (c, next) => {
+        // verify a token, then c.set("userId", ...)
+        await next();
+    },
+);
+```
+
+Hide a route or subtree from `openapi.json` with `export const openapi = false` (in a verb file
+or a `+shared.ts`). Hidden routes still serve normally.
+
+## Lifecycle
+
+`src/main.ts` is the optional home for imperative startup — opening pools, validating env,
+graceful shutdown. Giri owns the serve and calls these hooks; the adapter still binds the port.
+
+```ts
+// src/main.ts
+import type { Services } from "@boon4681/giri";
+
+export const init = () => {
+    // leave init unannotated — its return type is the source of truth for c.app
+    return { db: connectDb(process.env.DATABASE_URL) };
+};
+
+export const teardown = (services: Services) => {
+    return services.db.close();            // runs on SIGINT / SIGTERM
+};
+```
+
+Flow: load `main.ts` -> `await init()` -> hold services -> adapter serves -> `teardown` on
+exit. `init` runs once and is not re-run on watch rebuilds. The returned object reaches every
+handler as a typed `c.app`, inferred from `init`'s return — no declaration needed.
+
+## CLI
+
+| Command      | What it does                                                                       |
+| ------------ | ---------------------------------------------------------------------------------- |
+| `giri init`  | Scaffold `giri.config.ts`, a starter route, tsconfig paths, and `.gitignore`.      |
+| `giri sync`  | Scan `src/routes` and regenerate `.giri/` (manifest, param types, `openapi.json`). |
+| `giri serve` | `sync`, run `init()`, then serve via the adapter. Watches `src/` and re-syncs.     |
+| `giri build` | Planned — currently a no-op.                                                       |
+
+`giri serve` flags: `--port <n>`, `--host <addr>`, `--no-watch`.
+
+## Generated output (`.giri/`)
+
+Everything derived lives in `.giri/` at the project root: param `.d.ts` per route, the route
+manifest, and the assembled `openapi.json`. It is gitignored and rebuilt on demand — never edit
+it, only import from it.
+
+## Example
+
+See [`example/`](example) for a runnable Hono app:
+
+```sh
+cd example
+yarn install
+yarn sync
+yarn dev
+```
+
+## License
+
+MIT

package/dist/adapters/hono.d.ts

@@ -0,0 +1,7 @@
+import { Hono } from 'hono';
+import { G as GiriAdapter } from '../types-BrUMxh5u.js';
+
+type HonoGiriApp = Hono;
+declare function hono(): GiriAdapter<HonoGiriApp>;
+
+export { type HonoGiriApp, hono };

package/dist/adapters/hono.js

@@ -0,0 +1,301 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/hono.ts
+var hono_exports = {};
+__export(hono_exports, {
+  hono: () => hono
+});
+module.exports = __toCommonJS(hono_exports);
+var import_node_server = require("@hono/node-server");
+var import_hono = require("hono");
+
+// src/types.ts
+var typedResponseBrand = /* @__PURE__ */ Symbol.for("giri.typed-response");
+var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
+
+// src/context.ts
+var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+function createTypedResponse(data, status, format, headers) {
+  return {
+    [typedResponseBrand]: { data, status, format },
+    data,
+    status,
+    format,
+    headers
+  };
+}
+function isTypedResponse(value) {
+  return Boolean(value && typeof value === "object" && typedResponseBrand in value);
+}
+function createContext(options) {
+  const url = new URL(options.request.url);
+  const store = /* @__PURE__ */ new Map();
+  const validated = options.validated ?? {};
+  return {
+    params: options.params ?? {},
+    app: options.app ?? {},
+    req: {
+      raw: options.request,
+      url,
+      method: options.request.method,
+      header: (name) => options.request.headers.get(name),
+      json: () => options.request.json(),
+      text: () => options.request.text(),
+      arrayBuffer: () => options.request.arrayBuffer(),
+      formData: () => options.request.formData(),
+      valid: (key) => {
+        if (!(key in validated)) {
+          throw new Error(`No validated ${String(key)} data is available for this route.`);
+        }
+        return validated[key];
+      }
+    },
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    get: (key) => store.get(key),
+    json: (data, status = 200, headers) => createTypedResponse(data, status, "json", headers),
+    text: (text, status = 200, headers) => createTypedResponse(text, status, "text", headers)
+  };
+}
+function typedResponseToResponse(response) {
+  const headers = new Headers(response.headers);
+  if (response.format === "json" && !headers.has("content-type")) {
+    headers.set("content-type", "application/json; charset=utf-8");
+  }
+  if (response.format === "text" && !headers.has("content-type")) {
+    headers.set("content-type", "text/plain; charset=utf-8");
+  }
+  const body = BODYLESS_STATUS.has(response.status) ? null : response.format === "json" ? JSON.stringify(response.data) : String(response.data);
+  return new Response(body, {
+    status: response.status,
+    headers
+  });
+}
+function toResponse(response) {
+  return isTypedResponse(response) ? typedResponseToResponse(response) : response;
+}
+async function composeMiddleware(middleware, handle, context) {
+  let index = -1;
+  let result;
+  const dispatch = async (i) => {
+    if (i <= index) {
+      throw new Error("next() called multiple times in giri middleware.");
+    }
+    index = i;
+    if (i === middleware.length) {
+      result = await handle(context);
+      return result;
+    }
+    const returned = await middleware[i](context, () => dispatch(i + 1));
+    if (returned !== void 0) {
+      result = returned;
+      return returned;
+    }
+    return result;
+  };
+  await dispatch(0);
+  if (result === void 0) {
+    throw new Error("Route completed without returning a response.");
+  }
+  return result;
+}
+
+// src/validation.ts
+function isGiriInputSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[inputSchemaBrand] === true
+  );
+}
+var MIME_TO_CONTENT_TYPE = {
+  "application/json": "json",
+  "multipart/form-data": "form",
+  "application/x-www-form-urlencoded": "urlencoded",
+  "text/plain": "text"
+};
+function contentTypeFromHeader(header) {
+  if (!header) {
+    return void 0;
+  }
+  const mime = header.split(";", 1)[0].trim().toLowerCase();
+  return MIME_TO_CONTENT_TYPE[mime];
+}
+function formDataObject(form) {
+  const result = {};
+  form.forEach((value, key) => {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
+    }
+  });
+  return result;
+}
+async function readRawBody(request, contentType) {
+  const cloned = request.clone();
+  if (contentType === "json") {
+    return cloned.json();
+  }
+  if (contentType === "text") {
+    return cloned.text();
+  }
+  return formDataObject(await cloned.formData());
+}
+function queryObject(url) {
+  const result = {};
+  for (const [key, value] of url.searchParams) {
+    const current = result[key];
+    if (current === void 0) {
+      result[key] = value;
+    } else if (Array.isArray(current)) {
+      current.push(value);
+    } else {
+      result[key] = [current, value];
+    }
+  }
+  return result;
+}
+async function runValidation(schema, value, label) {
+  if (!isGiriInputSchema(schema)) {
+    throw new Error(
+      `giri: ${label} schema must be wrapped with a validator, e.g. \`export const ${label} = zod(...)\` from @boon4681/giri/validators/zod.`
+    );
+  }
+  return schema.validate(value);
+}
+async function prepareRequestInput(request, input) {
+  const validated = {};
+  if (input?.query) {
+    const query = queryObject(new URL(request.url));
+    const result = await runValidation(input.query, query, "query");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid query parameters.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.query = result.value;
+  }
+  if (input?.body) {
+    const contents = input.body.contents;
+    const declared = Object.keys(contents);
+    const requested = contentTypeFromHeader(request.headers.get("content-type"));
+    const chosen = requested && contents[requested] ? requested : contents.json ? "json" : void 0;
+    if (!chosen) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Unsupported media type.", issues: { accepted: declared } },
+          415,
+          "json"
+        )
+      };
+    }
+    let rawBody;
+    try {
+      rawBody = await readRawBody(request, chosen);
+    } catch (error) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: error },
+          400,
+          "json"
+        )
+      };
+    }
+    const result = await runValidation(contents[chosen], rawBody, "body");
+    if (!result.ok) {
+      return {
+        ok: false,
+        response: createTypedResponse(
+          { message: "Invalid request body.", issues: result.issues },
+          400,
+          "json"
+        )
+      };
+    }
+    validated.body = declared.length > 1 ? { type: chosen, data: result.value } : result.value;
+  }
+  return { ok: true, validated };
+}
+
+// src/adapters/hono.ts
+async function routeHandler(honoContext, route) {
+  const prepared = await prepareRequestInput(honoContext.req.raw, route.input);
+  if (!prepared.ok) {
+    return toResponse(prepared.response);
+  }
+  const context = createContext({
+    request: honoContext.req.raw,
+    params: honoContext.req.param(),
+    validated: prepared.validated,
+    app: route.services
+  });
+  const result = await composeMiddleware(route.middleware, route.handle, context);
+  return toResponse(result);
+}
+function registerHonoRoute(app, route) {
+  const handler = (c) => routeHandler(c, route);
+  const method = route.method.toLowerCase();
+  const appMethods = app;
+  if (method in app && typeof appMethods[method] === "function") {
+    appMethods[method](route.path, handler);
+    return;
+  }
+  throw new Error(`Hono adapter does not support ${route.method}.`);
+}
+function hono() {
+  return {
+    name: "hono",
+    createApp: () => new import_hono.Hono({ strict: false }),
+    register: registerHonoRoute,
+    fetch: async (app, req) => app.fetch(req),
+    serve: (handler, options, onListen) => {
+      const server = (0, import_node_server.serve)(
+        {
+          fetch: handler,
+          port: options.port,
+          hostname: options.hostname
+        },
+        onListen ? (info) => onListen({ address: info.address, port: info.port }) : void 0
+      );
+      return {
+        close: () => {
+          return new Promise((resolve, reject) => {
+            server.close((error) => error ? reject(error) : resolve());
+          });
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hono
+});
+//# sourceMappingURL=hono.js.map

package/dist/adapters/hono.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/adapters/hono.ts","../../src/types.ts","../../src/context.ts","../../src/validation.ts"],"sourcesContent":["import { serve as serveNode } from '@hono/node-server';\nimport { Hono } from 'hono';\nimport type { Context as HonoContext } from 'hono';\nimport { composeMiddleware, createContext, toResponse } from '../context';\nimport type { GiriAdapter, GiriRouteRegistration } from '../types';\nimport { prepareRequestInput } from '../validation';\n\nexport type HonoGiriApp = Hono;\n\nasync function routeHandler(honoContext: HonoContext, route: GiriRouteRegistration): Promise<Response> {\n    const prepared = await prepareRequestInput(honoContext.req.raw, route.input);\n    if (!prepared.ok) {\n        return toResponse(prepared.response);\n    }\n\n    const context = createContext({\n        request: honoContext.req.raw,\n        params: honoContext.req.param() as Record<string, string>,\n        validated: prepared.validated,\n        app: route.services,\n    });\n    const result = await composeMiddleware(route.middleware, route.handle, context);\n    return toResponse(result);\n}\n\nfunction registerHonoRoute(app: Hono, route: GiriRouteRegistration): void {\n    type HonoHandler = (c: HonoContext) => Promise<Response>;\n\n    const handler: HonoHandler = (c) => routeHandler(c, route);\n    const method = route.method.toLowerCase();\n    const appMethods = app as never as Record<string, (path: string, handler: HonoHandler) => void>;\n\n    if (method in app && typeof appMethods[method] === 'function') {\n        appMethods[method](route.path, handler);\n        return;\n    }\n\n    throw new Error(`Hono adapter does not support ${route.method}.`);\n}\n\nexport function hono(): GiriAdapter<HonoGiriApp> {\n    return {\n        name: 'hono',\n        createApp: () => new Hono({ strict: false }),\n        register: registerHonoRoute,\n        fetch: async (app, req) => app.fetch(req),\n        serve: (handler, options, onListen) => {\n            const server = serveNode(\n                {\n                    fetch: handler,\n                    port: options.port,\n                    hostname: options.hostname,\n                },\n                onListen ? (info) => onListen({ address: info.address, port: info.port }) : undefined,\n            );\n\n            return {\n                close: () => {\n                    return new Promise<void>((resolve, reject) => {\n                        server.close((error) => (error ? reject(error) : resolve()));\n                    })\n                }\n            };\n        },\n    };\n}\n","export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'OPTIONS' | 'HEAD';\n\nexport type StatusCode = number;\n\nexport type ResponseFormat = 'json' | 'text';\n\nexport const typedResponseBrand: unique symbol = Symbol.for('giri.typed-response') as never;\n\nexport interface TypedResponse<\n    T,\n    S extends StatusCode = StatusCode,\n    F extends ResponseFormat = ResponseFormat,\n> {\n    readonly [typedResponseBrand]: {\n        data: T;\n        status: S;\n        format: F;\n    };\n    readonly data: T;\n    readonly status: S;\n    readonly format: F;\n    readonly headers?: HeadersInit;\n}\n\nexport type HandlerResponse = Response | TypedResponse<unknown, StatusCode, ResponseFormat>;\n\nexport interface ValidatedInput {\n    /**\n     * The validated request body. For a single declared content-type it's that schema's\n     * output; for several it's a discriminated union `{ type; data }` (see `ValidBody`).\n     */\n    body?: unknown;\n    query?: unknown;\n}\n\nexport interface GiriRequest<Input extends ValidatedInput = ValidatedInput> {\n    raw: Request;\n    url: URL;\n    method: string;\n    header(name: string): string | null;\n    json<T = unknown>(): Promise<T>;\n    text(): Promise<string>;\n    arrayBuffer(): Promise<ArrayBuffer>;\n    formData(): Promise<FormData>;\n    valid<K extends keyof Input & ('body' | 'query')>(key: K): Input[K];\n}\n\ndeclare global {\n    /**\n     * Global registration surface for app-wide types. `giri sync` augments\n     * `Giri.Register[\"app\"]` from `src/main.ts` `init()` return type so `c.app` is\n     * typed without per-route generics (the registration pattern).\n     */\n    namespace Giri {\n        interface Register {}\n    }\n}\n\n/**\n * The app-wide services container, the type of `c.app`. `giri sync` infers it from\n * `src/main.ts`'s `init()` return type (via the global `Giri.Register` augmentation);\n * until then it falls back to an open record. Leave `init` unannotated (its return is\n * the source of truth) and annotate `teardown`'s parameter with this:\n *\n * ```ts\n * export const init = () => ({ db });            // inferred\n * export const teardown = (services: Services) => services.db.close();\n * ```\n */\nexport type Services = Giri.Register extends { app: infer A }\n    ? A\n    : Record<string, unknown>;\n\nexport interface Context<\n    Params extends Record<string, string> = Record<string, string>,\n    Input extends ValidatedInput = ValidatedInput,\n    Vars extends Record<string, unknown> = {},\n> {\n    params: Params;\n    /** App-wide services from `src/main.ts`'s `init()`, seeded into every request. */\n    app: Services;\n    req: GiriRequest<Input>;\n    // Context vars (`c.set`/`c.get`). Keys declared by middleware (`Vars`) are typed;\n    // any other key stays open (`unknown`) so untracked keys still work.\n    set<K extends keyof Vars & string>(key: K, value: Vars[K]): void;\n    set<K extends string>(key: K, value: unknown): void;\n    get<K extends keyof Vars & string>(key: K): Vars[K];\n    get<V = unknown>(key: string): V;\n    json<T, S extends StatusCode = 200>(\n        data: T,\n        status?: S,\n        headers?: HeadersInit,\n    ): TypedResponse<T, S, 'json'>;\n    text<S extends StatusCode = 200>(\n        text: string,\n        status?: S,\n        headers?: HeadersInit,\n    ): TypedResponse<string, S, 'text'>;\n}\n\nexport type Handle<\n    Params extends Record<string, string> = Record<string, string>,\n    Input extends ValidatedInput = ValidatedInput,\n    Vars extends Record<string, unknown> = {},\n> = (c: Context<Params, Input, Vars>) => HandlerResponse | Promise<HandlerResponse>;\n\nexport type Next = () => Promise<HandlerResponse | void>;\n\n/** An OpenAPI security requirement, e.g. `{ bearerAuth: [] }`. */\nexport type SecurityRequirement = Record<string, string[]>;\n\nexport interface MiddlewareOpenApi {\n    /** Security requirements this middleware enforces */\n    security?: SecurityRequirement[];\n    /** Optional scheme definitions, merged into `components.securitySchemes` so the doc is self-contained. */\n    securitySchemes?: Record<string, unknown>;\n    [key: string]: unknown;\n}\n\nexport interface MiddlewareOptions {\n    openapi?: MiddlewareOpenApi;\n}\n\nexport interface Middleware<\n    Params extends Record<string, string> = Record<string, string>,\n    Input extends ValidatedInput = ValidatedInput,\n    Vars extends Record<string, unknown> = {},\n> {\n    (c: Context<Params, Input, Vars>, next: Next): HandlerResponse | void | Promise<HandlerResponse | void>;\n    openapi?: MiddlewareOpenApi;\n}\n\n/** The context vars a middleware injects (its `Vars` type parameter). */\nexport type VarsOf<M> = M extends Middleware<Record<string, string>, ValidatedInput, infer V>\n    ? V\n    : {};\n\n/** Intersect the injected vars of a tuple of middleware (built with `stack(...)`). */\nexport type MergeStack<T> = T extends readonly [infer Head, ...infer Rest]\n    ? VarsOf<Head> & MergeStack<Rest>\n    : {};\n\n/**\n * Merge the vars from a middleware stack export. A plain `Middleware[]` (not a `stack(...)` tuple)\n */\nexport type InferStackVars<T> = T extends readonly [unknown, ...unknown[]] ? MergeStack<T> : {};\n\n/**\n * The vars injected by a module own `middleware` export (a `stack(...)`). Used by the\n * generated per-method handle so a verb file's own `export const middleware` types\n * `c.get`/`c.set`, on top of the folder's `+shared.ts` chain.\n */\nexport type MiddlewareVarsOf<M> = M extends { middleware: infer Stack }\n    ? InferStackVars<Stack>\n    : {};\n\n/** A JSON Schema object (JSON Schema 2020-12 / OpenAPI 3.1 dialect). */\nexport type JsonSchema = Record<string, unknown>;\n\nexport const inputSchemaBrand: unique symbol = Symbol.for('giri.input-schema') as never;\n\nexport type InputValidationResult<Output = unknown> =\n    | { ok: true; value: Output }\n    | { ok: false; issues: unknown };\n\n/**\n * A input schema every wrapper form (`body`/`query`) export takes. A vendor\n * adapter (`@boon4681/giri/validators/zod`, `@boon4681/giri/validators/valibot`, …) returns one; build a\n * custom one with `defineInputSchema`. giri core depends only on this interface, never\n * on a validator library. `validate` is the runtime check; `toJsonSchema` feeds OpenAPI.\n */\nexport interface GiriInputSchema<Output = unknown> {\n    readonly [inputSchemaBrand]: true;\n    validate(value: unknown): InputValidationResult<Output> | Promise<InputValidationResult<Output>>;\n    toJsonSchema(): JsonSchema;\n}\n\n/** Extract the validated output type of a giri input schema: `Infer<typeof body>`. */\nexport type Infer<T> = T extends GiriInputSchema<infer Output> ? Output : never;\n\nexport type BodyContentType = 'json' | 'form' | 'urlencoded' | 'text';\n\nexport const bodySchemaBrand: unique symbol = Symbol.for('giri.body-schema') as never;\n\n/**\n * A request body declared as a set of accepted content-types wrapped form `body`\n * takes (`zod.body({ json, form })`). One key means that encoding only; several mean the\n * endpoint accepts any of them, dispatched at runtime on the request `Content-Type`.\n * Each entry is a plain `GiriInputSchema`, so `validate`/`toJsonSchema` work per content-type.\n */\nexport interface GiriBodySchema<\n    Outputs extends Partial<Record<BodyContentType, unknown>> = Partial<Record<BodyContentType, unknown>>,\n> {\n    readonly [bodySchemaBrand]: true;\n    readonly contents: { [K in keyof Outputs & BodyContentType]: GiriInputSchema<Outputs[K]> };\n}\n\n/** True when `T` is a union of more than one member. */\ntype IsUnion<T, U = T> = T extends unknown ? ([U] extends [T] ? false : true) : never;\n\n/**\n * The validated body a handler receives. A single declared content-type yields that\n * schema's output directly; several yield a discriminated union keyed by content-type.\n */\nexport type ValidBody<B> = B extends GiriBodySchema<infer Outputs>\n    ? IsUnion<keyof Outputs> extends true\n        ? { [K in keyof Outputs]: { type: K; data: Outputs[K] } }[keyof Outputs]\n        : Outputs[keyof Outputs]\n    : never;\n\n/** The validated query a handler receives. */\nexport type ValidQuery<Q> = Q extends GiriInputSchema<infer Output> ? Output : never;\n\n/** Drop keys whose value resolved to `never` (an input the route didn't declare). */\ntype PruneNever<T> = { [K in keyof T as [T[K]] extends [never] ? never : K]: T[K] };\n\n/**\n * Derive a route's `ValidatedInput` from a module's `body`/`query` exports. The generated\n * per-method `$types` handle (`POST`, `GET`, …) uses this so handlers infer `c.req.valid`\n * with no manual generic.\n */\nexport type RouteInputOf<M> = PruneNever<{\n    body: M extends { body: infer B } ? ValidBody<B> : never;\n    query: M extends { query: infer Q } ? ValidQuery<Q> : never;\n}>;\n\nexport interface RouteInput {\n    body?: GiriBodySchema;\n    query?: GiriInputSchema;\n}\n\nexport interface RouteOpenApi {\n    /** Omit this route from the generated `openapi.json` (it still serves normally). */\n    hidden?: boolean;\n    // Room to grow: summary, description, tags, deprecated, operationId, …\n}\n\nexport type RouteOpenApiConfig = RouteOpenApi | boolean;\n\nexport interface GiriRouteRegistration {\n    method: HttpMethod;\n    path: string;\n    handle: Handle;\n    middleware: Middleware[];\n    input?: RouteInput;\n    /** App-wide services to seed onto `c.app` (same instance for every route). */\n    services?: Services;\n}\n\nexport type GiriFetchHandler = (req: Request) => Response | Promise<Response>;\n\nexport interface GiriServeOptions {\n    port: number;\n    hostname?: string;\n}\n\nexport interface GiriServerInfo {\n    address: string;\n    port: number;\n}\n\nexport interface GiriServer {\n    close(): void | Promise<void>;\n}\n\nexport interface GiriAdapter<App> {\n    name?: string;\n    createApp(): App;\n    register(app: App, route: GiriRouteRegistration): void;\n    fetch(app: App, req: Request): Promise<Response>;\n    /**\n     * Bind the configured backend's runtime to a port and start serving.\n     * giri core stays runtime-agnostic: it hands the adapter a request handler\n     * (so hot-reload keeps working) and the adapter owns the actual server.\n     */\n    serve(\n        handler: GiriFetchHandler,\n        options: GiriServeOptions,\n        onListen?: (info: GiriServerInfo) => void,\n    ): GiriServer;\n}\n\nexport interface GiriConfig<App = unknown> {\n    adapter: GiriAdapter<App>;\n    alias?: Record<string, string | string[]>;\n    outDir?: string;\n    server?: {\n        port?: number;\n        hostname?: string;\n    };\n    errorSchema?: unknown;\n}\n\nexport interface GiriPaths {\n    cwd: string;\n    routesDir: string;\n    outDir: string;\n}\n","import {\n    type Services,\n    type Context,\n    type HandlerResponse,\n    type Middleware,\n    type MiddlewareOptions,\n    type ResponseFormat,\n    type StatusCode,\n    type TypedResponse,\n    type ValidatedInput,\n    typedResponseBrand,\n} from './types';\n\nconst BODYLESS_STATUS = new Set([101, 103, 204, 205, 304]);\n\nexport interface CreateContextOptions<\n    Params extends Record<string, string> = Record<string, string>,\n    Input extends ValidatedInput = ValidatedInput,\n> {\n    request: Request;\n    params?: Params;\n    validated?: Input;\n    app?: Services;\n}\n\nexport function createTypedResponse<\n    T,\n    S extends StatusCode,\n    F extends ResponseFormat,\n>(data: T, status: S, format: F, headers?: HeadersInit): TypedResponse<T, S, F> {\n    return {\n        [typedResponseBrand]: { data, status, format },\n        data,\n        status,\n        format,\n        headers,\n    };\n}\n\nexport function isTypedResponse(value: unknown): value is TypedResponse<unknown> {\n    return Boolean(value && typeof value === 'object' && typedResponseBrand in value);\n}\n\nexport function createContext<\n    Params extends Record<string, string> = Record<string, string>,\n    Input extends ValidatedInput = ValidatedInput,\n>(options: CreateContextOptions<Params, Input>): Context<Params, Input> {\n    const url = new URL(options.request.url);\n    const store = new Map<string, unknown>();\n    const validated = options.validated ?? ({} as Input);\n\n    return {\n        params: options.params ?? ({} as Params),\n        app: options.app ?? ({} as Services),\n        req: {\n            raw: options.request,\n            url,\n            method: options.request.method,\n            header: (name) => options.request.headers.get(name),\n            json: <T = unknown>() => options.request.json() as Promise<T>,\n            text: () => options.request.text(),\n            arrayBuffer: () => options.request.arrayBuffer(),\n            formData: () => options.request.formData(),\n            valid: (key) => {\n                if (!(key in validated)) {\n                    throw new Error(`No validated ${String(key)} data is available for this route.`);\n                }\n                return validated[key];\n            },\n        },\n        set: (key: string, value: unknown) => {\n            store.set(key, value);\n        },\n        get: (key: string) => store.get(key) as never,\n        json: (data, status = 200 as never, headers) =>\n            createTypedResponse(data, status, 'json', headers),\n        text: (text, status = 200 as never, headers) =>\n            createTypedResponse(text, status, 'text', headers),\n    };\n}\n\nexport function typedResponseToResponse(response: TypedResponse<unknown>): Response {\n    const headers = new Headers(response.headers);\n\n    if (response.format === 'json' && !headers.has('content-type')) {\n        headers.set('content-type', 'application/json; charset=utf-8');\n    }\n\n    if (response.format === 'text' && !headers.has('content-type')) {\n        headers.set('content-type', 'text/plain; charset=utf-8');\n    }\n\n    const body = BODYLESS_STATUS.has(response.status)\n        ? null\n        : response.format === 'json'\n            ? JSON.stringify(response.data)\n            : String(response.data);\n\n    return new Response(body, {\n        status: response.status,\n        headers,\n    });\n}\n\nexport function toResponse(response: HandlerResponse): Response {\n    return isTypedResponse(response) ? typedResponseToResponse(response) : response;\n}\n\nexport async function composeMiddleware(\n    middleware: Middleware[],\n    handle: (c: Context) => HandlerResponse | Promise<HandlerResponse>,\n    context: Context,\n): Promise<HandlerResponse> {\n    let index = -1;\n    let result: HandlerResponse | undefined;\n\n    const dispatch = async (i: number): Promise<HandlerResponse | void> => {\n        if (i <= index) {\n            throw new Error('next() called multiple times in giri middleware.');\n        }\n        index = i;\n\n        if (i === middleware.length) {\n            result = await handle(context);\n            return result;\n        }\n\n        const returned = await middleware[i](context, () => dispatch(i + 1));\n        if (returned !== undefined) {\n            result = returned;\n            return returned;\n        }\n        return result;\n    };\n\n    await dispatch(0);\n\n    if (result === undefined) {\n        throw new Error('Route completed without returning a response.');\n    }\n\n    return result;\n}\n\ntype AnyMiddleware<Vars extends Record<string, unknown>> = Middleware<\n    Record<string, string>,\n    ValidatedInput,\n    Vars\n>;\n\nexport function defineMiddleware<Vars extends Record<string, unknown> = {}>(\n    middleware: AnyMiddleware<Vars>,\n): AnyMiddleware<Vars>;\nexport function defineMiddleware<Vars extends Record<string, unknown> = {}>(\n    options: MiddlewareOptions,\n    middleware: AnyMiddleware<Vars>,\n): AnyMiddleware<Vars>;\nexport function defineMiddleware(\n    optionsOrMiddleware: MiddlewareOptions | Middleware,\n    maybeMiddleware?: Middleware,\n): Middleware {\n    if (typeof optionsOrMiddleware === 'function') {\n        return optionsOrMiddleware;\n    }\n\n    if (!maybeMiddleware) {\n        throw new Error('defineMiddleware(options, middleware) requires a middleware function.');\n    }\n\n    maybeMiddleware.openapi = optionsOrMiddleware.openapi;\n    return maybeMiddleware;\n}\n\n/**\n * Group middleware into an ordered stack, preserving each element's type as a tuple so\n * the injected context vars (`defineMiddleware<Vars>` / `Middleware<…, Vars>`) propagate\n * to downstream handlers. Use it for `+shared.ts` and verb `middleware` exports:\n * `export const middleware = stack(auth, requireAdmin)`.\n */\n// `Vars` is contravariant (it sits in the `c` parameter), so the constraint must leave it\n// open (`any`) otherwise a middleware that injects vars isn't assignable to the element type.\nexport function stack<T extends Middleware<Record<string, string>, ValidatedInput, any>[]>(...middleware: T): T {\n    return middleware;\n}\n","import {\n    type BodyContentType,\n    type GiriBodySchema,\n    type GiriInputSchema,\n    type InputValidationResult,\n    type RouteInput,\n    type TypedResponse,\n    type ValidatedInput,\n    bodySchemaBrand,\n    inputSchemaBrand,\n} from './types';\nimport { createTypedResponse } from './context';\n\ninterface PreparedInput {\n    ok: true;\n    validated: ValidatedInput;\n}\n\ninterface FailedInput {\n    ok: false;\n    response: TypedResponse<{ message: string; issues: unknown }, 400 | 415, 'json'>;\n}\n\nexport type PreparedRequestInput = PreparedInput | FailedInput;\n\n/**\n * Build a giri input schema from a `validate` + `toJsonSchema` pair. Vendor adapters use\n * this; you can call it directly to make a custom validator. The brand is a global symbol,\n * so a hand-rolled `{ [Symbol.for(\"giri.input-schema\")]: true, validate, toJsonSchema }` works too.\n */\nexport function defineInputSchema<Output>(\n    schema: Omit<GiriInputSchema<Output>, typeof inputSchemaBrand>,\n): GiriInputSchema<Output> {\n    return { [inputSchemaBrand]: true, ...schema };\n}\n\nexport function isGiriInputSchema(value: unknown): value is GiriInputSchema {\n    return Boolean(\n        value &&\n            typeof value === 'object' &&\n            (value as Record<symbol, unknown>)[inputSchemaBrand] === true,\n    );\n}\n\n/**\n * Build a giri body schema from per-content-type input schemas. Validator adapters use this `zod.body({ json, form })`\n */\nexport function defineBodySchema<Outputs extends Partial<Record<BodyContentType, unknown>>>(\n    contents: GiriBodySchema<Outputs>['contents'],\n): GiriBodySchema<Outputs> {\n    return { [bodySchemaBrand]: true, contents };\n}\n\nexport function isGiriBodySchema(value: unknown): value is GiriBodySchema {\n    return Boolean(\n        value &&\n            typeof value === 'object' &&\n            (value as Record<symbol, unknown>)[bodySchemaBrand] === true,\n    );\n}\n\nconst MIME_TO_CONTENT_TYPE: Record<string, BodyContentType> = {\n    'application/json': 'json',\n    'multipart/form-data': 'form',\n    'application/x-www-form-urlencoded': 'urlencoded',\n    'text/plain': 'text',\n};\n\nfunction contentTypeFromHeader(header: string | null): BodyContentType | undefined {\n    if (!header) {\n        return undefined;\n    }\n    const mime = header.split(';', 1)[0].trim().toLowerCase();\n    return MIME_TO_CONTENT_TYPE[mime];\n}\n\n/** Flatten a `FormData` into a plain object, collapsing repeated fields into arrays. */\nfunction formDataObject(form: FormData): Record<string, unknown> {\n    const result: Record<string, unknown> = {};\n    form.forEach((value, key) => {\n        const current = result[key];\n        if (current === undefined) {\n            result[key] = value;\n        } else if (Array.isArray(current)) {\n            current.push(value);\n        } else {\n            result[key] = [current, value];\n        }\n    });\n    return result;\n}\n\nasync function readRawBody(request: Request, contentType: BodyContentType): Promise<unknown> {\n    const cloned = request.clone();\n    if (contentType === 'json') {\n        return cloned.json();\n    }\n    if (contentType === 'text') {\n        return cloned.text();\n    }\n    return formDataObject(await cloned.formData());\n}\n\nfunction queryObject(url: URL): Record<string, string | string[]> {\n    const result: Record<string, string | string[]> = {};\n    for (const [key, value] of url.searchParams) {\n        const current = result[key];\n        if (current === undefined) {\n            result[key] = value;\n        } else if (Array.isArray(current)) {\n            current.push(value);\n        } else {\n            result[key] = [current, value];\n        }\n    }\n    return result;\n}\n\nasync function runValidation(\n    schema: GiriInputSchema,\n    value: unknown,\n    label: string,\n): Promise<InputValidationResult> {\n    if (!isGiriInputSchema(schema)) {\n        throw new Error(\n            `giri: ${label} schema must be wrapped with a validator, e.g. \\`export const ${label} = zod(...)\\` from @boon4681/giri/validators/zod.`,\n        );\n    }\n    return schema.validate(value);\n}\n\nexport async function prepareRequestInput(request: Request, input?: RouteInput): Promise<PreparedRequestInput> {\n    const validated: ValidatedInput = {};\n\n    if (input?.query) {\n        const query = queryObject(new URL(request.url));\n        const result = await runValidation(input.query, query, 'query');\n        if (!result.ok) {\n            return {\n                ok: false,\n                response: createTypedResponse(\n                    { message: 'Invalid query parameters.', issues: result.issues },\n                    400,\n                    'json',\n                ),\n            };\n        }\n        validated.query = result.value;\n    }\n\n    if (input?.body) {\n        const contents = input.body.contents as Record<BodyContentType, GiriInputSchema>;\n        const declared = Object.keys(contents) as BodyContentType[];\n        const requested = contentTypeFromHeader(request.headers.get('content-type'));\n        // Pick the schema matching the request's content-type; fall back to JSON when the\n        // header is missing/unrecognized but JSON is on offer (so header-less posts still work).\n        const chosen: BodyContentType | undefined =\n            requested && contents[requested] ? requested : contents.json ? 'json' : undefined;\n\n        if (!chosen) {\n            return {\n                ok: false,\n                response: createTypedResponse(\n                    { message: 'Unsupported media type.', issues: { accepted: declared } },\n                    415,\n                    'json',\n                ),\n            };\n        }\n\n        let rawBody: unknown;\n        try {\n            rawBody = await readRawBody(request, chosen);\n        } catch (error) {\n            return {\n                ok: false,\n                response: createTypedResponse(\n                    { message: 'Invalid request body.', issues: error },\n                    400,\n                    'json',\n                ),\n            };\n        }\n\n        const result = await runValidation(contents[chosen], rawBody, 'body');\n        if (!result.ok) {\n            return {\n                ok: false,\n                response: createTypedResponse(\n                    { message: 'Invalid request body.', issues: result.issues },\n                    400,\n                    'json',\n                ),\n            };\n        }\n\n        validated.body = declared.length > 1 ? { type: chosen, data: result.value } : result.value;\n    }\n\n    return { ok: true, validated };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAmC;AACnC,kBAAqB;;;ACKd,IAAM,qBAAoC,uBAAO,IAAI,qBAAqB;AAyJ1E,IAAM,mBAAkC,uBAAO,IAAI,mBAAmB;;;AClJ7E,IAAM,kBAAkB,oBAAI,IAAI,CAAC,KAAK,KAAK,KAAK,KAAK,GAAG,CAAC;AAYlD,SAAS,oBAId,MAAS,QAAW,QAAW,SAA+C;AAC5E,SAAO;AAAA,IACH,CAAC,kBAAkB,GAAG,EAAE,MAAM,QAAQ,OAAO;AAAA,IAC7C;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AACJ;AAEO,SAAS,gBAAgB,OAAiD;AAC7E,SAAO,QAAQ,SAAS,OAAO,UAAU,YAAY,sBAAsB,KAAK;AACpF;AAEO,SAAS,cAGd,SAAsE;AACpE,QAAM,MAAM,IAAI,IAAI,QAAQ,QAAQ,GAAG;AACvC,QAAM,QAAQ,oBAAI,IAAqB;AACvC,QAAM,YAAY,QAAQ,aAAc,CAAC;AAEzC,SAAO;AAAA,IACH,QAAQ,QAAQ,UAAW,CAAC;AAAA,IAC5B,KAAK,QAAQ,OAAQ,CAAC;AAAA,IACtB,KAAK;AAAA,MACD,KAAK,QAAQ;AAAA,MACb;AAAA,MACA,QAAQ,QAAQ,QAAQ;AAAA,MACxB,QAAQ,CAAC,SAAS,QAAQ,QAAQ,QAAQ,IAAI,IAAI;AAAA,MAClD,MAAM,MAAmB,QAAQ,QAAQ,KAAK;AAAA,MAC9C,MAAM,MAAM,QAAQ,QAAQ,KAAK;AAAA,MACjC,aAAa,MAAM,QAAQ,QAAQ,YAAY;AAAA,MAC/C,UAAU,MAAM,QAAQ,QAAQ,SAAS;AAAA,MACzC,OAAO,CAAC,QAAQ;AACZ,YAAI,EAAE,OAAO,YAAY;AACrB,gBAAM,IAAI,MAAM,gBAAgB,OAAO,GAAG,CAAC,oCAAoC;AAAA,QACnF;AACA,eAAO,UAAU,GAAG;AAAA,MACxB;AAAA,IACJ;AAAA,IACA,KAAK,CAAC,KAAa,UAAmB;AAClC,YAAM,IAAI,KAAK,KAAK;AAAA,IACxB;AAAA,IACA,KAAK,CAAC,QAAgB,MAAM,IAAI,GAAG;AAAA,IACnC,MAAM,CAAC,MAAM,SAAS,KAAc,YAChC,oBAAoB,MAAM,QAAQ,QAAQ,OAAO;AAAA,IACrD,MAAM,CAAC,MAAM,SAAS,KAAc,YAChC,oBAAoB,MAAM,QAAQ,QAAQ,OAAO;AAAA,EACzD;AACJ;AAEO,SAAS,wBAAwB,UAA4C;AAChF,QAAM,UAAU,IAAI,QAAQ,SAAS,OAAO;AAE5C,MAAI,SAAS,WAAW,UAAU,CAAC,QAAQ,IAAI,cAAc,GAAG;AAC5D,YAAQ,IAAI,gBAAgB,iCAAiC;AAAA,EACjE;AAEA,MAAI,SAAS,WAAW,UAAU,CAAC,QAAQ,IAAI,cAAc,GAAG;AAC5D,YAAQ,IAAI,gBAAgB,2BAA2B;AAAA,EAC3D;AAEA,QAAM,OAAO,gBAAgB,IAAI,SAAS,MAAM,IAC1C,OACA,SAAS,WAAW,SAChB,KAAK,UAAU,SAAS,IAAI,IAC5B,OAAO,SAAS,IAAI;AAE9B,SAAO,IAAI,SAAS,MAAM;AAAA,IACtB,QAAQ,SAAS;AAAA,IACjB;AAAA,EACJ,CAAC;AACL;AAEO,SAAS,WAAW,UAAqC;AAC5D,SAAO,gBAAgB,QAAQ,IAAI,wBAAwB,QAAQ,IAAI;AAC3E;AAEA,eAAsB,kBAClB,YACA,QACA,SACwB;AACxB,MAAI,QAAQ;AACZ,MAAI;AAEJ,QAAM,WAAW,OAAO,MAA+C;AACnE,QAAI,KAAK,OAAO;AACZ,YAAM,IAAI,MAAM,kDAAkD;AAAA,IACtE;AACA,YAAQ;AAER,QAAI,MAAM,WAAW,QAAQ;AACzB,eAAS,MAAM,OAAO,OAAO;AAC7B,aAAO;AAAA,IACX;AAEA,UAAM,WAAW,MAAM,WAAW,CAAC,EAAE,SAAS,MAAM,SAAS,IAAI,CAAC,CAAC;AACnE,QAAI,aAAa,QAAW;AACxB,eAAS;AACT,aAAO;AAAA,IACX;AACA,WAAO;AAAA,EACX;AAEA,QAAM,SAAS,CAAC;AAEhB,MAAI,WAAW,QAAW;AACtB,UAAM,IAAI,MAAM,+CAA+C;AAAA,EACnE;AAEA,SAAO;AACX;;;AC1GO,SAAS,kBAAkB,OAA0C;AACxE,SAAO;AAAA,IACH,SACI,OAAO,UAAU,YAChB,MAAkC,gBAAgB,MAAM;AAAA,EACjE;AACJ;AAmBA,IAAM,uBAAwD;AAAA,EAC1D,oBAAoB;AAAA,EACpB,uBAAuB;AAAA,EACvB,qCAAqC;AAAA,EACrC,cAAc;AAClB;AAEA,SAAS,sBAAsB,QAAoD;AAC/E,MAAI,CAAC,QAAQ;AACT,WAAO;AAAA,EACX;AACA,QAAM,OAAO,OAAO,MAAM,KAAK,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE,YAAY;AACxD,SAAO,qBAAqB,IAAI;AACpC;AAGA,SAAS,eAAe,MAAyC;AAC7D,QAAM,SAAkC,CAAC;AACzC,OAAK,QAAQ,CAAC,OAAO,QAAQ;AACzB,UAAM,UAAU,OAAO,GAAG;AAC1B,QAAI,YAAY,QAAW;AACvB,aAAO,GAAG,IAAI;AAAA,IAClB,WAAW,MAAM,QAAQ,OAAO,GAAG;AAC/B,cAAQ,KAAK,KAAK;AAAA,IACtB,OAAO;AACH,aAAO,GAAG,IAAI,CAAC,SAAS,KAAK;AAAA,IACjC;AAAA,EACJ,CAAC;AACD,SAAO;AACX;AAEA,eAAe,YAAY,SAAkB,aAAgD;AACzF,QAAM,SAAS,QAAQ,MAAM;AAC7B,MAAI,gBAAgB,QAAQ;AACxB,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,MAAI,gBAAgB,QAAQ;AACxB,WAAO,OAAO,KAAK;AAAA,EACvB;AACA,SAAO,eAAe,MAAM,OAAO,SAAS,CAAC;AACjD;AAEA,SAAS,YAAY,KAA6C;AAC9D,QAAM,SAA4C,CAAC;AACnD,aAAW,CAAC,KAAK,KAAK,KAAK,IAAI,cAAc;AACzC,UAAM,UAAU,OAAO,GAAG;AAC1B,QAAI,YAAY,QAAW;AACvB,aAAO,GAAG,IAAI;AAAA,IAClB,WAAW,MAAM,QAAQ,OAAO,GAAG;AAC/B,cAAQ,KAAK,KAAK;AAAA,IACtB,OAAO;AACH,aAAO,GAAG,IAAI,CAAC,SAAS,KAAK;AAAA,IACjC;AAAA,EACJ;AACA,SAAO;AACX;AAEA,eAAe,cACX,QACA,OACA,OAC8B;AAC9B,MAAI,CAAC,kBAAkB,MAAM,GAAG;AAC5B,UAAM,IAAI;AAAA,MACN,SAAS,KAAK,iEAAiE,KAAK;AAAA,IACxF;AAAA,EACJ;AACA,SAAO,OAAO,SAAS,KAAK;AAChC;AAEA,eAAsB,oBAAoB,SAAkB,OAAmD;AAC3G,QAAM,YAA4B,CAAC;AAEnC,MAAI,OAAO,OAAO;AACd,UAAM,QAAQ,YAAY,IAAI,IAAI,QAAQ,GAAG,CAAC;AAC9C,UAAM,SAAS,MAAM,cAAc,MAAM,OAAO,OAAO,OAAO;AAC9D,QAAI,CAAC,OAAO,IAAI;AACZ,aAAO;AAAA,QACH,IAAI;AAAA,QACJ,UAAU;AAAA,UACN,EAAE,SAAS,6BAA6B,QAAQ,OAAO,OAAO;AAAA,UAC9D;AAAA,UACA;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AACA,cAAU,QAAQ,OAAO;AAAA,EAC7B;AAEA,MAAI,OAAO,MAAM;AACb,UAAM,WAAW,MAAM,KAAK;AAC5B,UAAM,WAAW,OAAO,KAAK,QAAQ;AACrC,UAAM,YAAY,sBAAsB,QAAQ,QAAQ,IAAI,cAAc,CAAC;AAG3E,UAAM,SACF,aAAa,SAAS,SAAS,IAAI,YAAY,SAAS,OAAO,SAAS;AAE5E,QAAI,CAAC,QAAQ;AACT,aAAO;AAAA,QACH,IAAI;AAAA,QACJ,UAAU;AAAA,UACN,EAAE,SAAS,2BAA2B,QAAQ,EAAE,UAAU,SAAS,EAAE;AAAA,UACrE;AAAA,UACA;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAEA,QAAI;AACJ,QAAI;AACA,gBAAU,MAAM,YAAY,SAAS,MAAM;AAAA,IAC/C,SAAS,OAAO;AACZ,aAAO;AAAA,QACH,IAAI;AAAA,QACJ,UAAU;AAAA,UACN,EAAE,SAAS,yBAAyB,QAAQ,MAAM;AAAA,UAClD;AAAA,UACA;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAEA,UAAM,SAAS,MAAM,cAAc,SAAS,MAAM,GAAG,SAAS,MAAM;AACpE,QAAI,CAAC,OAAO,IAAI;AACZ,aAAO;AAAA,QACH,IAAI;AAAA,QACJ,UAAU;AAAA,UACN,EAAE,SAAS,yBAAyB,QAAQ,OAAO,OAAO;AAAA,UAC1D;AAAA,UACA;AAAA,QACJ;AAAA,MACJ;AAAA,IACJ;AAEA,cAAU,OAAO,SAAS,SAAS,IAAI,EAAE,MAAM,QAAQ,MAAM,OAAO,MAAM,IAAI,OAAO;AAAA,EACzF;AAEA,SAAO,EAAE,IAAI,MAAM,UAAU;AACjC;;;AH/LA,eAAe,aAAa,aAA0B,OAAiD;AACnG,QAAM,WAAW,MAAM,oBAAoB,YAAY,IAAI,KAAK,MAAM,KAAK;AAC3E,MAAI,CAAC,SAAS,IAAI;AACd,WAAO,WAAW,SAAS,QAAQ;AAAA,EACvC;AAEA,QAAM,UAAU,cAAc;AAAA,IAC1B,SAAS,YAAY,IAAI;AAAA,IACzB,QAAQ,YAAY,IAAI,MAAM;AAAA,IAC9B,WAAW,SAAS;AAAA,IACpB,KAAK,MAAM;AAAA,EACf,CAAC;AACD,QAAM,SAAS,MAAM,kBAAkB,MAAM,YAAY,MAAM,QAAQ,OAAO;AAC9E,SAAO,WAAW,MAAM;AAC5B;AAEA,SAAS,kBAAkB,KAAW,OAAoC;AAGtE,QAAM,UAAuB,CAAC,MAAM,aAAa,GAAG,KAAK;AACzD,QAAM,SAAS,MAAM,OAAO,YAAY;AACxC,QAAM,aAAa;AAEnB,MAAI,UAAU,OAAO,OAAO,WAAW,MAAM,MAAM,YAAY;AAC3D,eAAW,MAAM,EAAE,MAAM,MAAM,OAAO;AACtC;AAAA,EACJ;AAEA,QAAM,IAAI,MAAM,iCAAiC,MAAM,MAAM,GAAG;AACpE;AAEO,SAAS,OAAiC;AAC7C,SAAO;AAAA,IACH,MAAM;AAAA,IACN,WAAW,MAAM,IAAI,iBAAK,EAAE,QAAQ,MAAM,CAAC;AAAA,IAC3C,UAAU;AAAA,IACV,OAAO,OAAO,KAAK,QAAQ,IAAI,MAAM,GAAG;AAAA,IACxC,OAAO,CAAC,SAAS,SAAS,aAAa;AACnC,YAAM,aAAS,mBAAAA;AAAA,QACX;AAAA,UACI,OAAO;AAAA,UACP,MAAM,QAAQ;AAAA,UACd,UAAU,QAAQ;AAAA,QACtB;AAAA,QACA,WAAW,CAAC,SAAS,SAAS,EAAE,SAAS,KAAK,SAAS,MAAM,KAAK,KAAK,CAAC,IAAI;AAAA,MAChF;AAEA,aAAO;AAAA,QACH,OAAO,MAAM;AACT,iBAAO,IAAI,QAAc,CAAC,SAAS,WAAW;AAC1C,mBAAO,MAAM,CAAC,UAAW,QAAQ,OAAO,KAAK,IAAI,QAAQ,CAAE;AAAA,UAC/D,CAAC;AAAA,QACL;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACJ;","names":["serveNode"]}

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node