@rshono/core 1.0.0-rc.1 → 1.0.0-rc.10

package/dist/runtime/context.d.ts

@@ -1,5 +1,5 @@
 /**
- * The request context: {@link getContext} and the {@link Ctx} wrapper it returns,
+ * The request context: {@link getRequestContext} and the {@link RequestContext} wrapper it returns,
  * the {@link redirect} / {@link notFound} control-flow helpers, and the
  * {@link onServerError} reporting funnel — plus the `@internal` plumbing that binds
  * a request to the async context in the first place.
@@ -9,7 +9,7 @@
  * here is safe in a `'use client'` module — those run in the browser, with no bound
  * request context.
  */
-import type { Context, Env, HonoRequest } from 'hono';
+import type { Context, Env } from 'hono';
 import type { CookieOptions } from 'hono/utils/cookie';
 /**
  * HTTP status codes accepted by {@link redirect}.
@@ -18,153 +18,293 @@ import type { CookieOptions } from 'hono/utils/cookie';
  * - `302` Found, `307` Temporary Redirect — temporary.
  * - `303` See Other — the default; forces a `GET` on the target, which is what
  *   you almost always want after a form action (post/redirect/get).
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Status#redirection_messages | MDN — redirection status codes}
  */
 export type RedirectStatus = 301 | 302 | 303 | 307 | 308;
+/**
+ * Marks the request as having entered its page render, which is what makes
+ * {@link RequestContext.setHeader} and `ctx.cookies.set()` start throwing.
+ *
+ * Framework internal — `renderComponent` calls this immediately before handing the page to React.
+ * Everything that legitimately writes to the response (middleware, a `'use server'` action, an
+ * endpoint route) has already run by then, so none of them are affected.
+ *
+ * @internal
+ */
+export declare function beginPageRender(c: Context): void;
 /**
  * Runs `fn` with the given Hono {@link Context} bound as the ambient request
- * context, so that {@link getContext} resolves to it anywhere in the call tree.
+ * context, so that {@link getRequestContext} resolves to it anywhere in the call tree.
  *
  * Framework internal — the request handler wraps every render and action in
- * this. Application code should reach for {@link getContext} instead.
+ * this. Application code should reach for {@link getRequestContext} instead.
  *
  * @internal
  */
 export declare function runWithContext<T>(c: Context, fn: () => T): T;
 /**
- * Reads the matched route params, returning an empty object when there is no
- * active route match (rather than throwing). Shared by {@link Ctx.params} and the
- * request renderer so the fallback behaviour stays in one place.
+ * The matched route params, or an empty object when there is no active match.
  *
- * Framework internal — read params from {@link Ctx.params} or a page's
- * `PageProps` instead.
+ * Framework internal — the request renderer calls this to build a page's `params` prop, and
+ * {@link RequestContext.params} caches it. Read them from that prop, or from `ctx.params`.
  *
  * @internal
  */
 export declare function readParams(c: Context): Record<string, string>;
 /**
- * Resolves the browser-facing {@link URL} for a request.
+ * Resolves the browser-facing {@link URL} for a request, from a Hono {@link Context}.
  *
- * `c.req.url` reflects the internal address the server was reached on, which is wrong behind a
- * proxy or load balancer. `X-Forwarded-Host` / `X-Forwarded-Proto` fix that up — **but only when
- * `trustProxy` is enabled in `rshono.config.ts`** (always the case under `rshono dev`). Those
- * headers are client-supplied: honouring them unconditionally lets anyone who can reach the server
- * dictate the origin of every absolute URL the app builds — canonical tags, emails, redirects — and
- * poison a shared cache with them. So the default is to ignore them entirely.
+ * `c.req.url` reflects the internal address the server was reached on, which is wrong behind a proxy.
+ * `X-Forwarded-Host` / `X-Forwarded-Proto` fix that up — **but only when `trustProxy` is enabled in
+ * `rshono.config.ts`** (always so under `rshono dev`). They are client-supplied, so honouring them
+ * unconditionally would let anyone who can reach the server dictate the origin of every absolute URL
+ * the app builds, and poison a shared cache with it.
  *
- * Framework internal — prefer {@link Ctx.url}, which caches the result per request.
+ * This is the form for **middleware**, which is handed `c` and runs outside the request context. In
+ * a server component or a `'use server'` action prefer {@link RequestContext.url}, which is this same
+ * value cached per request.
  *
- * @internal
+ * Its main use is giving Hono's own middleware the origin the browser actually used, since they all
+ * read `c.req.url` on their own and so see the internal one:
+ *
+ * @example
+ * ```ts
+ * // src/server.ts — a CSRF check that still works behind a proxy that rewrites Host
+ * import { publicUrl } from '@rshono/core/server';
+ * import { csrf } from 'hono/csrf';
+ *
+ * server.use(csrf({ origin: (origin, c) => origin === publicUrl(c).origin }));
+ * ```
+ *
+ * A fresh instance per call, so mutating it disturbs nothing else.
+ *
+ * @param c - The Hono {@link Context} for the request.
+ * @returns The browser-facing URL — proxy-corrected under `trustProxy`, `c.req.url` otherwise.
+ *
+ * @see {@link https://www.rshono.com/docs/configuration#proxy-headers | Docs — proxy headers}
  */
 export declare function publicUrl(c: Context): URL;
 /**
  * The environment available to a request: Cloudflare/Workers `Bindings` merged
  * with process env vars. Values not declared in `Bindings` are typed as
- * `string | undefined`. See {@link Ctx.env}.
+ * `string | undefined`. See {@link RequestContext.env}.
+ *
+ * @see {@link https://hono.dev/docs/getting-started/cloudflare-workers#bindings | Hono — bindings}
  */
 export type EnvVars<E extends Env> = E['Bindings'] & Record<string, string | undefined>;
 /**
  * Ergonomic, read-mostly wrapper around Hono's {@link Context} for use inside
  * server components and server actions.
  *
- * Obtain one with {@link getContext}, or — in a page component — take it straight
+ * Obtain one with {@link getRequestContext}, or — in a page component — take it straight
  * off the `ctx` prop, which is this same object. Never construct it yourself. One
  * instance is reused for the lifetime of a request, so its lazy getters
- * ({@link Ctx.url}, {@link Ctx.env}) are computed at most once.
+ * ({@link RequestContext.url}, {@link RequestContext.env}) are computed at most once.
  *
  * @typeParam E - The Hono {@link Env} describing this app's `Bindings` and
- *   `Variables`, so {@link Ctx.var} and {@link Ctx.env} stay typed.
+ *   `Variables`, so {@link RequestContext.var} and {@link RequestContext.env} stay typed.
  *
  * @example
  * ```tsx
- * import { getContext } from '@rshono/core/server';
+ * import { getRequestContext } from '@rshono/core/server';
  *
  * export default async function Whoami() {
- *   const ctx = getContext();
+ *   const ctx = getRequestContext();
  *   const session = ctx.cookies.get('session');
  *   return <p>{ctx.url.pathname} — {session ?? 'anonymous'}</p>;
  * }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}
+ * @see {@link https://hono.dev/docs/api/context | Hono — Context}, reachable in full via {@link RequestContext.hono}
  */
-export declare class Ctx<E extends Env = Env> {
+export declare class RequestContext<E extends Env = Env> {
     #private;
+    /**
+     * Framework internal — one instance is created per request and handed to you by
+     * {@link getRequestContext} or the `ctx` page prop. Application code never calls this.
+     *
+     * @internal
+     */
     constructor(c: Context<E>);
     /**
-     * The underlying Hono {@link Context}. Escape hatch for anything this wrapper does not expose.
+     * The underlying Hono {@link Context} — the escape hatch for what this wrapper does not expose,
+     * such as `executionCtx.waitUntil()` on Workers.
+     *
+     * Its response builders (`redirect`, `notFound`, `json`, `body`, `status`, …) still do nothing from
+     * inside a page, for the reason the stubs on this class explain: reaching them through here
+     * bypasses the error, it does not make them work.
+     *
+     * @example
+     * ```ts
+     * getRequestContext().hono.executionCtx.waitUntil(logAsync()); // Workers
+     * ```
      *
-     * A getter over a private field rather than a plain property, so it is not an *own enumerable*
-     * one — which matters more than it looks. React's diagnostic for a value that cannot be sent to a
-     * client component (`describeObjectForErrorMessage`) walks `Object.keys` recursively with no depth
-     * limit and no cycle guard, and the Hono context graph reaches the socket and the whole server
-     * through `req.raw` and `env`. While this was a plain property, passing a `Ctx` to a `'use client'`
-     * component blew the stack *inside that message builder* — so React's actual, accurate "you cannot
-     * pass this" error never got printed. Hidden from `Object.keys`, the walk stops here.
+     * @see {@link https://hono.dev/docs/api/context | Hono — Context}
      */
-    get raw(): Context<E>;
-    /** The parsed Hono request (`c.req`) — headers, body parsing, param access, etc. */
-    get req(): HonoRequest;
+    get hono(): Context<E>;
     /**
-     * The browser-facing request URL, proxy-header aware (see {@link publicUrl}) —
-     * read `url.pathname`, `url.searchParams` and the rest off it. Parsed once and
-     * cached, so the same instance comes back on every read within a request; treat
-     * it as read-only for that reason.
+     * The parsed request — method, headers, path params, query and the body readers. Hono's
+     * {@link Context.req}, unwrapped, so `ctx.req.header('authorization')` rather than
+     * `ctx.hono.req.header(…)`.
+     *
+     * Reads only. Setting a *response* header is {@link RequestContext.setHeader}, deliberately in a
+     * different place — Hono's `c.header()` writing the response while `c.req.header()` reads the
+     * request is a well-worn source of confusion.
+     *
+     * @example
+     * ```ts
+     * const ctx = getRequestContext();
+     * ctx.req.method;                     // 'GET'
+     * ctx.req.header('authorization');    // string | undefined
+     * ctx.req.query('tab');               // string | undefined
+     * ```
+     *
+     * @see {@link https://hono.dev/docs/api/request | Hono — HonoRequest}
      */
-    get url(): URL;
-    /** The HTTP method of the request, e.g. `GET` or `POST`. */
-    get method(): string;
+    get req(): Context<E>['req'];
     /**
-     * Matched route params, e.g. `{ id }` for a `/users/[id]` route. Returns an
-     * empty object when there is no active route match (rather than throwing).
+     * Matched route params for this request, e.g. `{ id: '42' }` for `/profile/:id`. Empty when there
+     * is no active route match.
+     *
+     * A **page** is handed the same record as its `params` prop, typed key-by-key from its route path,
+     * and that is the better read where it is available. This is for everywhere else — a nested server
+     * component, or a `'use server'` action — which get no props from the framework.
      */
     get params(): Record<string, string>;
+    /**
+     * The browser-facing request URL — read `url.pathname`, `url.searchParams` and the
+     * rest off it. Parsed once and cached, so the same instance comes back on every
+     * read within a request; treat it as read-only for that reason.
+     *
+     * `X-Forwarded-Host` / `-Proto` are honoured only when `trustProxy` is enabled in
+     * `rshono.config.ts`, since any client can send them.
+     *
+     * @see {@link https://www.rshono.com/docs/configuration#proxy-headers | Docs — proxy headers}
+     */
+    get url(): URL;
     /**
      * Typed variables set by middleware via `c.set('user', …)`, read here as
      * `ctx.var.user`. Type them by parameterising this class's {@link Env}.
+     *
+     * @example
+     * ```ts
+     * type AppEnv = { Variables: { user: { id: string } } };
+     * const { user } = getRequestContext<AppEnv>().var; // typed, set by your middleware
+     * ```
+     *
+     * @see {@link https://hono.dev/docs/api/context#var | Hono — c.var}
+     * @see {@link https://www.rshono.com/docs/hono#typing-the-context | Docs — typing the context}
      */
     get var(): Readonly<E['Variables']>;
     /**
      * Environment for the request: process env vars merged with runtime bindings
      * (bindings win on conflict). Computed once and cached.
      *
-     * @example `const key = getContext().env.STRIPE_SECRET_KEY;`
+     * @example `const key = getRequestContext().env.STRIPE_SECRET_KEY;`
+     *
+     * @see {@link https://hono.dev/docs/api/context#env | Hono — c.env}
+     * @see {@link https://www.rshono.com/docs/configuration#environment-and-secrets | Docs — environment and secrets}
      */
     get env(): EnvVars<E>;
-    /** Sets a response header. Thin pass-through to `c.header(name, value)`. */
-    header(name: string, value: string): void;
     /**
      * Read and write request/response cookies.
      *
      * @example
      * ```ts
-     * const ctx = getContext();
+     * const ctx = getRequestContext();
      * ctx.cookies.get('session');                       // string | undefined
      * ctx.cookies.set('session', id, { httpOnly: true, sameSite: 'Lax', path: '/' });
      * ctx.cookies.delete('session', { path: '/' });
      * ```
+     *
+     * @see {@link https://hono.dev/docs/helpers/cookie | Hono — cookie helper}, which this wraps
      */
     cookies: {
-        /** Reads a single cookie by name, or `undefined` if absent. */
+        /** Reads a single cookie by name, or `undefined` if absent. Safe anywhere, a page included. */
         get: (name: string) => string | undefined;
-        /** Reads every cookie as a `{ name: value }` record. */
+        /** Reads every cookie as a `{ name: value }` record. Safe anywhere, a page included. */
         all: () => Record<string, string>;
-        /** Sets a cookie on the response. See Hono's {@link CookieOptions} for `path`, `httpOnly`, `maxAge`, etc. */
+        /**
+         * Sets a cookie on the response. See Hono's {@link CookieOptions} for `path`, `httpOnly`,
+         * `maxAge`, etc.
+         *
+         * **Throws inside a page render** — see {@link RequestContext.setHeader}, of which a `Set-Cookie`
+         * is a special case. Set cookies from a `'use server'` action, or with Hono's `setCookie(c, …)`
+         * in middleware and endpoint routes.
+         *
+         * @throws If called while a page is rendering, where it could not reach the browser reliably.
+         *
+         * @see {@link https://hono.dev/docs/helpers/cookie#options | Hono — cookie options}
+         */
         set: (name: string, value: string, options?: CookieOptions) => void;
-        /** Clears a cookie. Pass the same `path`/`domain` it was set with so the browser matches it. */
+        /**
+         * Clears a cookie. Pass the same `path`/`domain` it was set with so the browser matches it.
+         * Throws inside a page render, exactly as `set` does.
+         *
+         * @throws If called while a page is rendering.
+         */
         delete: (name: string, options?: CookieOptions) => void;
     };
+    /**
+     * Sets a header on the response — from a `'use server'` action, which is the one place a request
+     * context exists *and* the response is still open.
+     *
+     * From inside a page it throws: a page streams, so by then the response head is committed. Hono's
+     * `c.header()` fails there silently and inconsistently — landing on a full page load, vanishing on
+     * a soft navigation — so this refuses rather than doing it half the time.
+     *
+     * Middleware and `{ type: 'endpoint' }` routes run outside the request context but are handed
+     * Hono's `c` directly, so they use `c.header(…)`. That is also where a header belonging to the
+     * *page* rather than to one action goes — `Cache-Control`, `X-Robots-Tag` — since middleware runs
+     * before the render.
+     *
+     * @param name - Header name, case-insensitive.
+     * @param value - Header value.
+     * @param options - `{ append: true }` to add another value rather than replace.
+     * @throws If called while a page is rendering, where it could not reach the browser reliably.
+     *
+     * @example
+     * ```ts
+     * 'use server';
+     * export async function logout() {
+     *   const ctx = getRequestContext();
+     *   ctx.cookies.delete('session', { path: '/' });
+     *   ctx.setHeader('clear-site-data', '"cache", "storage"');
+     *   redirect('/');
+     * }
+     * ```
+     */
+    setHeader(name: string, value: string, options?: {
+        append?: boolean;
+    }): void;
+    /** @deprecated Not available on a page's context — use `redirect()` from `@rshono/core/server`. */
+    redirect(...args: unknown[]): never;
+    /** @deprecated Not available on a page's context — use `notFound()` from `@rshono/core/server`. */
+    notFound(...args: unknown[]): never;
+    /** @deprecated A page renders JSX. For a JSON response, use an `{ type: 'endpoint' }` route. */
+    json(...args: unknown[]): never;
+    /** @deprecated A page renders JSX. For a text response, use an `{ type: 'endpoint' }` route. */
+    text(...args: unknown[]): never;
+    /** @deprecated A page renders JSX, which the framework turns into HTML for you. */
+    html(...args: unknown[]): never;
+    /** @deprecated Not available on a page's context. To read the request body, use `ctx.req`. */
+    body(...args: unknown[]): never;
+    /** @deprecated A page's status is set by the framework — use `notFound()`, or an endpoint route. */
+    status(...args: unknown[]): never;
+    /** @deprecated Renamed — use `ctx.setHeader(name, value)`, which is valid from a `'use server'` action. */
+    header(...args: unknown[]): never;
 }
 /**
- * Returns the {@link Ctx} for the current request.
- *
- * This is the primary entry point for reading request data from a server
- * component or server action — the URL, cookies, params, env, and middleware
- * variables. The returned wrapper is memoised per request, so repeated calls in
- * the same request are cheap and return the same instance.
+ * Returns the {@link RequestContext} for the current request — the URL, cookies, params, env and
+ * middleware variables, read from a server component or a server action. Memoised per request, so
+ * repeated calls return the same instance.
  *
- * A **page** component is handed the very same object as its `ctx` prop, so this
- * import is for everywhere else: a nested server component, or a `'use server'`
- * action module — neither of which receives props from the framework.
+ * A **page** component is handed that same object as its `ctx` prop, so this import is for everywhere
+ * else: a nested server component, or a `'use server'` action module.
  *
- * @typeParam E - The app's Hono {@link Env}, to type {@link Ctx.var} and {@link Ctx.env}.
+ * @typeParam E - The app's Hono {@link Env}, to type {@link RequestContext.var} and {@link RequestContext.env}.
  * @throws If called at module load, where there is no ambient context to resolve.
  * @throws If called while prerendering a `render: 'static'` route, which has no
  *   per-request context at build time — mark the route `render: 'dynamic'` instead.
@@ -172,15 +312,17 @@ export declare class Ctx<E extends Env = Env> {
  * @example
  * ```ts
  * 'use server';
- * import { getContext, redirect } from '@rshono/core/server';
+ * import { getRequestContext, redirect } from '@rshono/core/server';
  *
  * export async function login(form: FormData) {
- *   getContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
+ *   getRequestContext().cookies.set('session', String(form.get('email')), { httpOnly: true });
  *   redirect('/dashboard');
  * }
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/api#rshonocoreserver | Docs — `@rshono/core/server`}
  */
-export declare function getContext<E extends Env = Env>(): Ctx<E>;
+export declare function getRequestContext<E extends Env = Env>(): RequestContext<E>;
 /**
  * Redirects the request to `location` by throwing a control signal that the
  * framework catches and turns into an HTTP redirect response.
@@ -195,7 +337,7 @@ export declare function getContext<E extends Env = Env>(): Ctx<E>;
  *
  * @example
  * ```ts
- * const session = getContext().cookies.get('session');
+ * const session = getRequestContext().cookies.get('session');
  * if (!session) redirect('/login');
  * // session is defined below this line
  * ```
@@ -209,9 +351,11 @@ export declare function redirect(location: string, status?: RedirectStatus): nev
  *
  * @example
  * ```tsx
- * const user = await db.user.find(getContext().params.id);
- * if (!user) notFound();
- * return <Profile user={user} />; // user is non-null here
+ * export default async function Page({ params }: PageProps<'/users/:id'>) {
+ *   const user = await db.user.find(params.id);
+ *   if (!user) notFound();
+ *   return <Profile user={user} />; // user is non-null here
+ * }
  * ```
  */
 export declare function notFound(): never;
@@ -255,6 +399,8 @@ export type ServerErrorHandler = (error: unknown, context: ServerErrorContext) =
  *   Sentry.captureException(error, { tags: { source }, extra: { url: request.url } });
  * });
  * ```
+ *
+ * @see {@link https://www.rshono.com/docs/hono#error-reporting | Docs — error reporting}
  */
 export declare function onServerError(handler: ServerErrorHandler): void;
 /**

package/dist/runtime/context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"AACA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,MAAM,CAAC;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAIvD;;;;;;;GAOG;AACH,MAAM,MAAM,cAAc,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAkCzD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE5D;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAM7D;AAaD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAAE,OAAO,GAAG,GAAG,CAmBzC;AAED;;;;GAIG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,UAAU,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,GAAG,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG;;IAKlC,YAAY,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,EAExB;IAED;;;;;;;;;;OAUG;IACH,IAAI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAEpB;IAED,oFAAoF;IACpF,IAAI,GAAG,IAAI,WAAW,CAErB;IAED;;;;;OAKG;IACH,IAAI,GAAG,IAAI,GAAG,CAEb;IAED,4DAA4D;IAC5D,IAAI,MAAM,IAAI,MAAM,CAEnB;IAED;;;OAGG;IACH,IAAI,MAAM,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAEnC;IAED;;;OAGG;IACH,IAAI,GAAG,IAAI,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAElC;IAED;;;;;OAKG;IACH,IAAI,GAAG,IAAI,OAAO,CAAC,CAAC,CAAC,CAKpB;IAED,4EAA4E;IAC5E,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,CAExC;IAED;;;;;;;;;;OAUG;IACH,OAAO;QACL,+DAA+D;QAC/D,GAAG,SAAS,MAAM,KAAG,MAAM,GAAG,SAAS;QACvC,wDAAwD;QACxD,GAAG,QAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;QAC/B,6GAA6G;QAC7G,GAAG,SAAS,MAAM,SAAS,MAAM,YAAY,aAAa,KAAG,IAAI;QACjE,gGAAgG;QAChG,MAAM,SAAS,MAAM,YAAY,aAAa,KAAG,IAAI;MAGrD;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,GAAG,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC,CAAC,CAqBxD;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,GAAE,cAAoB,GAAG,KAAK,CAE9E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,QAAQ,IAAI,KAAK,CAEhC;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,KAAK,GAAG,SAAS,CAAC;AAExE,0FAA0F;AAC1F,MAAM,WAAW,kBAAkB;IACjC,kEAAkE;IAClE,MAAM,EAAE,iBAAiB,CAAC;IAC1B,iEAAiE;IACjE,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,8GAA8G;AAC9G,MAAM,MAAM,kBAAkB,GAAG,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,kBAAkB,KAAK,IAAI,CAAC;AAIvF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI,CAE/D;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,kBAAkB,GAAG;IAAE,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAQtG"}
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/runtime/context.ts"],"names":[],"mappings":"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"}