@boon4681/giri 0.0.3-alpha-3 → 0.0.3-alpha-4

package/README.md

@@ -228,6 +228,46 @@ yarn sync
 yarn dev
 ```
 
+## Portable runtime
+
+`@boon4681/giri/runtime` is the portable composition layer for generated integrations. It does
+not implement routing itself: it accepts a complete `GiriAdapter`, creates that adapter's app, and
+registers statically imported route modules. Hono is the supported adapter today:
+
+```ts
+import { createApp } from "@boon4681/giri/runtime";
+import { hono } from "@boon4681/giri/adapters/hono";
+import * as rootShared from "./src/routes/+shared";
+import * as usersGet from "./src/routes/users/+get";
+
+export const app = createApp({
+    adapter: hono(),
+    services: { source: "playground" },
+    routes: [
+        {
+            method: "GET",
+            path: "/api/users",
+            module: usersGet,
+            shared: [rootShared],
+        },
+    ],
+});
+```
+
+The result is a normal Fetch application:
+
+```ts
+const response = await app.fetch(new Request("https://example.test/api/users"));
+```
+
+`app` is the native Hono application, so SvelteKit or Next.js can forward a framework request
+directly to `app.fetch(request)`. This is the low-level target for virtual modules such as
+`@giri/project-1`; the Vite integration should generate the route descriptor array.
+
+The shipped Hono adapter also owns its Node server binding. A browser playground should provide a
+different `GiriAdapter` implementation whose `createApp`, `register`, `fetch`, and `serve` methods
+bind to the desired browser runtime; `createApp` itself does not special-case that environment.
+
 ## License
 
-MIT
+MIT

package/dist/adapters/hono.d.ts

@@ -1,5 +1,5 @@
 import { ContextVariableMap, Hono, MiddlewareHandler } from 'hono';
-import { M as Middleware, V as ValidatedInput, G as GiriAdapter } from '../types-BvRph0mx.js';
+import { M as Middleware, V as ValidatedInput, G as GiriAdapter } from '../types-DZ-14IP6.js';
 
 type HonoGiriApp = Hono;
 type HonoContextVars = {

package/dist/index.d.ts

@@ -1,65 +1,6 @@
-import { M as Middleware, C as Context, H as HandlerResponse, V as ValidatedInput, S as Services, c as CookieJarFactory, d as StatusCode, R as ResponseFormat, T as TypedResponse, e as MiddlewareOptions, B as BodyContentType, a as GiriBodySchema, b as GiriInputSchema, i as inputSchemaBrand, f as RouteInput, g as HttpMethod, h as GiriConfig, j as GiriPaths, k as SecurityRequirement } from './types-BvRph0mx.js';
-export { l as CookieJar, m as CookieOptions, n as CookieSink, G as GiriAdapter, o as GiriFetchHandler, p as GiriRequest, q as GiriRouteRegistration, r as GiriServeOptions, s as GiriServer, t as GiriServerInfo, u as Handle, I as Infer, v as InferStackVars, w as InputValidationResult, J as JsonSchema, x as MergeStack, y as MiddlewareOpenApi, z as MiddlewareVarsOf, N as Next, A as RouteInputOf, D as RouteOpenApi, E as RouteOpenApiConfig, F as ValidBody, K as ValidQuery, L as VarsOf } from './types-BvRph0mx.js';
-
-interface CreateContextOptions<Params extends Record<string, string> = Record<string, string>, Input extends ValidatedInput = ValidatedInput> {
-    request: Request;
-    params?: Params;
-    validated?: Input;
-    app?: Services;
-    /** The adapter's native per-request context, stashed for backend-specific bridges. */
-    native?: unknown;
-    /** Secret for `c.signedCookie` / `c.req.signedCookie` (from `config.cookieSecret`). */
-    cookieSecret?: string;
-    /** The adapter's cookie jar, built from its runtime's native helpers. */
-    cookies?: CookieJarFactory;
-}
-declare function createTypedResponse<T, S extends StatusCode, F extends ResponseFormat>(data: T, status: S, format: F, headers?: HeadersInit): TypedResponse<T, S, F>;
-declare function isTypedResponse(value: unknown): value is TypedResponse<unknown>;
-declare function createContext<Params extends Record<string, string> = Record<string, string>, Input extends ValidatedInput = ValidatedInput>(options: CreateContextOptions<Params, Input>): Context<Params, Input>;
-declare function typedResponseToResponse(response: TypedResponse<unknown>): Response;
-/**
- * Convert a handler's return value to a real `Response`, then merge any headers set imperatively via
- * `c.header()` (the response's own headers win; pending ones fill the gaps). Pass the `context` so
- * those imperative headers are applied; without it the response is returned unchanged.
- */
-declare function toResponse(response: HandlerResponse, context?: Context): Response;
-declare function composeMiddleware(middleware: Middleware[], handle: (c: Context) => HandlerResponse | Promise<HandlerResponse>, context: Context): Promise<HandlerResponse>;
-type AnyMiddleware<Vars extends Record<string, unknown>> = Middleware<Record<string, string>, ValidatedInput, Vars>;
-declare function defineMiddleware<Vars extends Record<string, unknown> = {}>(middleware: AnyMiddleware<Vars>): AnyMiddleware<Vars>;
-declare function defineMiddleware<Vars extends Record<string, unknown> = {}>(options: MiddlewareOptions, middleware: AnyMiddleware<Vars>): AnyMiddleware<Vars>;
-/**
- * Group middleware into an ordered stack, preserving each element's type as a tuple so
- * the injected context vars (`defineMiddleware<Vars>` / `Middleware<…, Vars>`) propagate
- * to downstream handlers. Use it for `+shared.ts` and verb `middleware` exports:
- * `export const middleware = stack(auth, requireAdmin)`.
- */
-declare function stack<T extends Middleware<Record<string, string>, ValidatedInput, any>[]>(...middleware: T): T;
-
-interface PreparedInput {
-    ok: true;
-    validated: ValidatedInput;
-}
-interface FailedInput {
-    ok: false;
-    response: TypedResponse<{
-        message: string;
-        issues: unknown;
-    }, 400 | 415, 'json'>;
-}
-type PreparedRequestInput = PreparedInput | FailedInput;
-/**
- * Build a giri input schema from a `validate` + `toJsonSchema` pair. Vendor adapters use
- * this; you can call it directly to make a custom validator. The brand is a global symbol,
- * so a hand-rolled `{ [Symbol.for("giri.input-schema")]: true, validate, toJsonSchema }` works too.
- */
-declare function defineInputSchema<Output>(schema: Omit<GiriInputSchema<Output>, typeof inputSchemaBrand>): GiriInputSchema<Output>;
-declare function isGiriInputSchema(value: unknown): value is GiriInputSchema;
-/**
- * Build a giri body schema from per-content-type input schemas. Validator adapters use this `zod.body({ json, form })`
- */
-declare function defineBodySchema<Outputs extends Partial<Record<BodyContentType, unknown>>>(contents: GiriBodySchema<Outputs>['contents']): GiriBodySchema<Outputs>;
-declare function isGiriBodySchema(value: unknown): value is GiriBodySchema;
-declare function prepareRequestInput(request: Request, input?: RouteInput): Promise<PreparedRequestInput>;
+import { H as HttpMethod, h as GiriConfig, S as Services, j as GiriPaths, B as BodyContentType, A as SecurityRequirement } from './types-DZ-14IP6.js';
+export { C as Context, d as CookieJar, e as CookieJarFactory, f as CookieOptions, g as CookieSink, G as GiriAdapter, b as GiriBodySchema, i as GiriFetchHandler, c as GiriInputSchema, k as GiriRequest, l as GiriRouteRegistration, m as GiriServeOptions, n as GiriServer, o as GiriServerInfo, a as Handle, p as HandlerResponse, I as Infer, q as InferStackVars, r as InputValidationResult, J as JsonSchema, s as MergeStack, M as Middleware, t as MiddlewareOpenApi, u as MiddlewareOptions, v as MiddlewareVarsOf, N as Next, w as RouteInput, x as RouteInputOf, y as RouteOpenApi, z as RouteOpenApiConfig, D as StatusCode, T as TypedResponse, E as ValidBody, F as ValidQuery, V as ValidatedInput, K as VarsOf } from './types-DZ-14IP6.js';
+export { c as composeMiddleware, a as createContext, b as createTypedResponse, d as defineBodySchema, e as defineInputSchema, f as defineMiddleware, i as isGiriBodySchema, g as isGiriInputSchema, h as isTypedResponse, p as prepareRequestInput, s as stack, t as toResponse, j as typedResponseToResponse } from './validation-Cma_ytxd.js';
 
 interface RouteParam {
     name: string;
@@ -189,4 +130,4 @@ declare function runInit(lifecycle: GiriLifecycle): Promise<Services>;
 
 declare function defineConfig<App>(config: GiriConfig<App>): GiriConfig<App>;
 
-export { BodyContentType, Context, CookieJarFactory, GiriBodySchema, GiriConfig, GiriInputSchema, type GiriLifecycle, GiriPaths, HandlerResponse, HttpMethod, Middleware, MiddlewareOptions, RouteInput, SecurityRequirement, Services, StatusCode, TypedResponse, ValidatedInput, buildGiriApp, composeMiddleware, createContext, createTypedResponse, defineBodySchema, defineConfig, defineInputSchema, defineMiddleware, isGiriBodySchema, isGiriInputSchema, isTypedResponse, loadLifecycle, prepareRequestInput, resolveGiriPaths, runInit, scanRoutes, stack, syncProject, toResponse, typedResponseToResponse };
+export { BodyContentType, GiriConfig, type GiriLifecycle, GiriPaths, HttpMethod, SecurityRequirement, Services, buildGiriApp, defineConfig, loadLifecycle, resolveGiriPaths, runInit, scanRoutes, syncProject };

package/dist/runtime.d.ts

@@ -0,0 +1,49 @@
+export { c as composeMiddleware, a as createContext, b as createTypedResponse, d as defineBodySchema, e as defineInputSchema, f as defineMiddleware, i as isGiriBodySchema, g as isGiriInputSchema, h as isTypedResponse, p as prepareRequestInput, s as stack, t as toResponse, j as typedResponseToResponse } from './validation-Cma_ytxd.js';
+import { G as GiriAdapter, H as HttpMethod, a as Handle, M as Middleware, b as GiriBodySchema, c as GiriInputSchema, S as Services } from './types-DZ-14IP6.js';
+export { B as BodyContentType, C as Context, d as CookieJar, e as CookieJarFactory, f as CookieOptions, g as CookieSink, h as GiriConfig, i as GiriFetchHandler, j as GiriPaths, k as GiriRequest, l as GiriRouteRegistration, m as GiriServeOptions, n as GiriServer, o as GiriServerInfo, p as HandlerResponse, I as Infer, q as InferStackVars, r as InputValidationResult, J as JsonSchema, s as MergeStack, t as MiddlewareOpenApi, u as MiddlewareOptions, v as MiddlewareVarsOf, N as Next, R as ResponseFormat, w as RouteInput, x as RouteInputOf, y as RouteOpenApi, z as RouteOpenApiConfig, A as SecurityRequirement, D as StatusCode, T as TypedResponse, E as ValidBody, F as ValidQuery, V as ValidatedInput, K as VarsOf, L as bodySchemaBrand, O as inputSchemaBrand, P as nativeContextBrand, Q as typedResponseBrand } from './types-DZ-14IP6.js';
+
+type AnyHandle = Handle<any, any, any>;
+type AnyMiddleware = Middleware<any, any, any>;
+interface GiriRuntimeRouteModule {
+    readonly handle: AnyHandle;
+    readonly middleware?: AnyMiddleware | readonly AnyMiddleware[];
+    readonly body?: GiriBodySchema;
+    readonly query?: GiriInputSchema;
+    readonly config?: {
+        readonly skipInherited?: boolean;
+    };
+}
+interface GiriRuntimeSharedModule {
+    readonly middleware?: AnyMiddleware | readonly AnyMiddleware[];
+}
+/**
+ * A route descriptor generated by a host integration.
+ *
+ * `module` and every `shared` entry should be statically imported module namespaces so Vite and
+ * other bundlers can discover the complete route graph.
+ */
+interface GiriRuntimeRoute {
+    readonly method: HttpMethod;
+    readonly path: string;
+    readonly module: GiriRuntimeRouteModule;
+    readonly shared?: readonly GiriRuntimeSharedModule[];
+}
+interface CreateGiriAppOptions<App> {
+    /** The complete runtime adapter that owns the app, routing, request dispatch, and serving. */
+    readonly adapter: GiriAdapter<App>;
+    /** Statically imported route modules, normally emitted by a virtual module or code generator. */
+    readonly routes: readonly GiriRuntimeRoute[];
+    /** App-wide services to seed onto `c.app` for every registered route. */
+    readonly services?: Services;
+    /** Secret passed to the adapter for signed cookie support. */
+    readonly cookieSecret?: string;
+}
+/**
+ * Construct a backend-native app and register Giri's generated route modules on it.
+ *
+ * Giri does not route requests here. The supplied adapter owns the runtime; this function is only
+ * the portable composition step used by generated and virtual modules.
+ */
+declare function createApp<App>(options: CreateGiriAppOptions<App>): App;
+
+export { type CreateGiriAppOptions, GiriAdapter, GiriBodySchema, GiriInputSchema, type GiriRuntimeRoute, type GiriRuntimeRouteModule, type GiriRuntimeSharedModule, Handle, HttpMethod, Middleware, Services, createApp };

package/dist/runtime.js

@@ -0,0 +1,464 @@
+"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/runtime.ts
+var runtime_exports = {};
+__export(runtime_exports, {
+  composeMiddleware: () => composeMiddleware,
+  createApp: () => createApp,
+  createContext: () => createContext,
+  createTypedResponse: () => createTypedResponse,
+  defineBodySchema: () => defineBodySchema,
+  defineInputSchema: () => defineInputSchema,
+  defineMiddleware: () => defineMiddleware,
+  isGiriBodySchema: () => isGiriBodySchema,
+  isGiriInputSchema: () => isGiriInputSchema,
+  isTypedResponse: () => isTypedResponse,
+  prepareRequestInput: () => prepareRequestInput,
+  stack: () => stack,
+  toResponse: () => toResponse,
+  typedResponseToResponse: () => typedResponseToResponse
+});
+module.exports = __toCommonJS(runtime_exports);
+
+// src/types.ts
+var typedResponseBrand = /* @__PURE__ */ Symbol.for("giri.typed-response");
+var nativeContextBrand = /* @__PURE__ */ Symbol.for("giri.native-context");
+var inputSchemaBrand = /* @__PURE__ */ Symbol.for("giri.input-schema");
+var bodySchemaBrand = /* @__PURE__ */ Symbol.for("giri.body-schema");
+
+// src/context.ts
+var BODYLESS_STATUS = /* @__PURE__ */ new Set([101, 103, 204, 205, 304]);
+var pendingResponseBrand = /* @__PURE__ */ Symbol("giri.pending-response");
+function getPending(context) {
+  return context[pendingResponseBrand];
+}
+var unsupportedCookieJar = {
+  get: cookiesUnsupported,
+  all: cookiesUnsupported,
+  set: cookiesUnsupported,
+  delete: cookiesUnsupported,
+  getSigned: cookiesUnsupported,
+  setSigned: cookiesUnsupported
+};
+function cookiesUnsupported() {
+  throw new Error("The active adapter does not support cookies.");
+}
+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 ?? {};
+  const pending = { headers: new Headers() };
+  const defaultStatus = () => pending.status ?? 200;
+  const cookies = options.cookies ? options.cookies({
+    request: options.request,
+    append: (header) => pending.headers.append("set-cookie", header),
+    secret: options.cookieSecret
+  }) : unsupportedCookieJar;
+  const context = {
+    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];
+      },
+      cookie: (name) => cookies.get(name),
+      cookies: () => cookies.all(),
+      signedCookie: (name) => cookies.getSigned(name)
+    },
+    set: (key, value) => {
+      store.set(key, value);
+    },
+    get: (key) => store.get(key),
+    json: (data, status, headers) => createTypedResponse(data, status ?? defaultStatus(), "json", headers),
+    text: (text, status, headers) => createTypedResponse(text, status ?? defaultStatus(), "text", headers),
+    html: (html, status, headers) => createTypedResponse(html, status ?? defaultStatus(), "html", headers),
+    body: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    newResponse: (data, status, headers) => new Response(data, { status: status ?? defaultStatus(), headers }),
+    redirect: (location, status) => new Response(null, { status: status ?? 302, headers: { Location: location } }),
+    notFound: () => new Response("404 Not Found", { status: 404 }),
+    header: (name, value, options2) => {
+      if (value === void 0) {
+        pending.headers.delete(name);
+      } else if (options2?.append) {
+        pending.headers.append(name, value);
+      } else {
+        pending.headers.set(name, value);
+      }
+    },
+    status: (code) => {
+      pending.status = code;
+    },
+    cookie: (name, value, options2) => {
+      if (value === null) {
+        cookies.delete(name, options2);
+      } else {
+        cookies.set(name, value, options2);
+      }
+    },
+    signedCookie: (name, value, options2) => cookies.setSigned(name, value, options2)
+  };
+  context[nativeContextBrand] = options.native;
+  context[pendingResponseBrand] = pending;
+  return context;
+}
+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");
+  }
+  if (response.format === "html" && !headers.has("content-type")) {
+    headers.set("content-type", "text/html; 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, context) {
+  const base = isTypedResponse(response) ? typedResponseToResponse(response) : response;
+  const pending = context ? getPending(context) : void 0;
+  if (!pending) {
+    return base;
+  }
+  let hasPending = false;
+  pending.headers.forEach(() => {
+    hasPending = true;
+  });
+  if (!hasPending) {
+    return base;
+  }
+  const headers = new Headers(base.headers);
+  pending.headers.forEach((value, key) => {
+    if (key === "set-cookie") {
+      return;
+    }
+    if (!headers.has(key)) {
+      headers.set(key, value);
+    }
+  });
+  for (const cookie of pending.headers.getSetCookie?.() ?? []) {
+    headers.append("set-cookie", cookie);
+  }
+  return new Response(base.body, { status: base.status, statusText: base.statusText, headers });
+}
+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;
+}
+function defineMiddleware(optionsOrMiddleware, maybeMiddleware) {
+  if (typeof optionsOrMiddleware === "function") {
+    return optionsOrMiddleware;
+  }
+  if (!maybeMiddleware) {
+    throw new Error("defineMiddleware(options, middleware) requires a middleware function.");
+  }
+  maybeMiddleware.openapi = optionsOrMiddleware.openapi;
+  return maybeMiddleware;
+}
+function stack(...middleware) {
+  return middleware;
+}
+
+// src/validation.ts
+function defineInputSchema(schema) {
+  return { [inputSchemaBrand]: true, ...schema };
+}
+function isGiriInputSchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[inputSchemaBrand] === true
+  );
+}
+function defineBodySchema(contents) {
+  return { [bodySchemaBrand]: true, contents };
+}
+function isGiriBodySchema(value) {
+  return Boolean(
+    value && typeof value === "object" && value[bodySchemaBrand] === 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/runtime.ts
+function normalizeRoutePath(path) {
+  if (!path.startsWith("/")) {
+    throw new Error(`Giri runtime route paths must start with "/": ${path}`);
+  }
+  return path;
+}
+function normalizeMiddleware(value, label) {
+  if (value === void 0) {
+    return [];
+  }
+  if (typeof value === "function") {
+    return [value];
+  }
+  if (!Array.isArray(value) || value.some((middleware) => typeof middleware !== "function")) {
+    throw new Error(`${label} middleware must be a function or an array of functions.`);
+  }
+  return [...value];
+}
+function routeInput(route) {
+  const input = {};
+  if (route.module.body !== void 0) {
+    if (!isGiriBodySchema(route.module.body)) {
+      throw new Error(
+        `${route.method} ${route.path}: body must be a wrapped Giri body schema.`
+      );
+    }
+    input.body = route.module.body;
+  }
+  if (route.module.query !== void 0) {
+    if (!isGiriInputSchema(route.module.query)) {
+      throw new Error(
+        `${route.method} ${route.path}: query must be a wrapped Giri input schema.`
+      );
+    }
+    input.query = route.module.query;
+  }
+  return input.body || input.query ? input : void 0;
+}
+function routeRegistration(route, options) {
+  const path = normalizeRoutePath(route.path);
+  if (!route.module || typeof route.module.handle !== "function") {
+    throw new Error(`${route.method} ${path}: route module must export a handle function.`);
+  }
+  const inherited = route.module.config?.skipInherited ? [] : (route.shared ?? []).flatMap(
+    (shared, index) => normalizeMiddleware(shared.middleware, `${route.method} ${path} shared[${index}]`)
+  );
+  return {
+    method: route.method,
+    path,
+    handle: route.module.handle,
+    middleware: [
+      ...inherited,
+      ...normalizeMiddleware(route.module.middleware, `${route.method} ${path}`)
+    ],
+    input: routeInput(route),
+    services: options.services,
+    cookieSecret: options.cookieSecret
+  };
+}
+function createApp(options) {
+  if (!options.adapter || typeof options.adapter.createApp !== "function") {
+    throw new Error("Giri runtime requires an adapter with createApp().");
+  }
+  if (typeof options.adapter.register !== "function") {
+    throw new Error("Giri runtime requires an adapter with register().");
+  }
+  const registered = /* @__PURE__ */ new Set();
+  const registrations = options.routes.map((route) => {
+    const registration = routeRegistration(route, options);
+    const key = `${registration.method} ${registration.path}`;
+    if (registered.has(key)) {
+      throw new Error(`Duplicate Giri runtime route: ${key}`);
+    }
+    registered.add(key);
+    return registration;
+  });
+  const app = options.adapter.createApp();
+  for (const registration of registrations) {
+    options.adapter.register(app, registration);
+  }
+  return app;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  composeMiddleware,
+  createApp,
+  createContext,
+  createTypedResponse,
+  defineBodySchema,
+  defineInputSchema,
+  defineMiddleware,
+  isGiriBodySchema,
+  isGiriInputSchema,
+  isTypedResponse,
+  prepareRequestInput,
+  stack,
+  toResponse,
+  typedResponseToResponse
+});
+//# sourceMappingURL=runtime.js.map