@forinda/kickjs 5.17.0 → 5.18.0-alpha.1

package/dist/context-DV7RjM9F.d.mts

@@ -1,445 +0,0 @@
-
-import { i as MetaValue, r as ExecutionContext } from "./execution-context-B4cfhivz.mjs";
-import { i as ProblemDetails } from "./errors-CRCTjEUK.mjs";
-import { S as QueryFieldConfig, T as TypedParsedQuery, t as ParseQueryOptions } from "./index-BtWJ9SLP.mjs";
-import { NextFunction, Request, Response } from "express";
-
-//#region src/http/context.d.ts
-/**
- * Input shape for the typed problem-detail convenience methods on
- * {@link ProblemSender} (`ctx.problem.notFound`, `.badRequest`, etc.) —
- * RFC 9457 details minus the `status`, which each method pre-fills.
- */
-type ProblemInput = Omit<ProblemDetails, 'status'>;
-/**
- * Callable response helper for RFC 9457 — Problem Details responses.
- * Returned by `ctx.problem`. Invoke directly for a fully-specified
- * payload, or use the named convenience methods to pre-fill `status` +
- * `title` for the common codes.
- *
- * Each call sets `Content-Type: application/problem+json` and serializes
- * the canonical shape (defaulting `type` to `about:blank` and `title` to
- * the IANA reason phrase per RFC 9457 §3.1.1 / §3.1.4).
- *
- * @example
- * ```ts
- * ctx.problem({
- *   type: 'https://api.example.com/problems/out-of-credit',
- *   status: 403,
- *   detail: 'Your balance is 30, but that costs 50.',
- *   balance: 30,                // extension per §3.2
- * })
- *
- * ctx.problem.notFound({ detail: 'User abc not found' })
- * ctx.problem.validation(zodResult.error.issues)
- * ```
- */
-interface ProblemSender {
-  (input: ProblemDetails): Response;
-  /** 400 Bad Request — RFC 9457. */
-  badRequest(input?: ProblemInput): Response;
-  /** 401 Unauthorized — RFC 9457. */
-  unauthorized(input?: ProblemInput): Response;
-  /** 403 Forbidden — RFC 9457. */
-  forbidden(input?: ProblemInput): Response;
-  /** 404 Not Found — RFC 9457. */
-  notFound(input?: ProblemInput): Response;
-  /** 409 Conflict — RFC 9457. */
-  conflict(input?: ProblemInput): Response;
-  /** 422 Unprocessable Entity — RFC 9457. */
-  unprocessable(input?: ProblemInput): Response;
-  /** 429 Too Many Requests — RFC 9457. */
-  tooManyRequests(input?: ProblemInput): Response;
-  /** 500 Internal Server Error — RFC 9457. */
-  internal(input?: ProblemInput): Response;
-  /**
-   * 422 with Zod issues serialized into the `errors` extension per
-   * RFC 9457 §3.2's array convention. Pass `error.issues` from a Zod
-   * `safeParse` failure or `error.issues` from a thrown ZodError.
-   */
-  validation(issues: any[], input?: ProblemInput): Response;
-}
-/**
- * Recursively marks every property of `T` as `readonly`. Preserves
- * `Function`, `Date`, and `RegExp` unchanged, and converts `Map` / `Set`
- * to `ReadonlyMap` / `ReadonlySet` so their mutating methods (`set`,
- * `delete`, `add`, `clear`) are removed from the public surface.
- * Tuples keep their positional element types — only their per-element
- * mutability is locked.
- *
- * Exposed as a utility for adopters who want to opt into compile-time
- * sealing of their own shapes. **No longer applied to
- * `RequestContext.{body,params,query,headers,file,files}`** — that
- * broke TS narrowing / discriminated-union drilldowns on typed request
- * payloads. Runtime read-only enforcement now lives in
- * {@link makeReadOnlyProxy} (dev-only Proxy that warns on writes,
- * no-op in production).
- *
- * Type-only. No runtime cost. `DeepReadonly<any>` is `any` (TS
- * distributes conditional types over `any`).
- */
-type DeepReadonly<T> = T extends ((...args: never[]) => unknown) ? T : T extends Date | RegExp ? T : T extends Map<infer K, infer V> ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>> : T extends Set<infer V> ? ReadonlySet<DeepReadonly<V>> : T extends readonly (infer U)[] ? number extends T['length'] ? ReadonlyArray<DeepReadonly<U>> : { readonly [K in keyof T]: DeepReadonly<T[K]> } : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;
-/**
- * The shape of a single route entry in `KickRoutes`. Generated by
- * `kick typegen` and consumed via the `Ctx<T>` helper. Each field is
- * `unknown` by default and is filled in as the typegen learns more
- * about the route (URL params from the path, body/query from validation
- * schemas, etc.).
- */
-interface RouteShape {
-  params?: unknown;
-  body?: unknown;
-  query?: unknown;
-  response?: unknown;
-}
-/**
- * Unified request/response abstraction passed to every controller method.
- * Shields handlers from raw Express objects and provides convenience methods.
- *
- * Implements {@link ExecutionContext} so the transport-agnostic Context
- * Contributor pipeline (#107) can run against this concrete HTTP context
- * the same way it will run against future WS / queue / cron contexts.
- */
-declare class RequestContext<TBody = any, TParams = any, TQuery = any> implements ExecutionContext {
-  readonly req: Request;
-  readonly res: Response;
-  readonly next: NextFunction;
-  constructor(req: Request, res: Response, next: NextFunction);
-  /**
-   * Memo of the most recent {@link qs} call this request. The query
-   * object is immutable for a request's lifetime, so a repeat call with
-   * the same `(fieldConfig, options)` references returns the cached
-   * parse instead of re-walking the filter/sort strings.
-   */
-  private _qsMemo?;
-  /**
-   * Read-side accessor for the per-request metadata map.
-   *
-   * Returns the AsyncLocalStorage map (`requestStore.getStore().values`)
-   * shared with the Context Contributor pipeline when an ALS frame is
-   * active. Returns `null` outside any frame — read-side callers
-   * (`ctx.get`, `ctx.user`, `ctx.tenantId`, `ctx.roles`) treat that as
-   * "no metadata" and fall through to their `req.*` defaults. Reads
-   * never throw because outside an ALS frame nobody could have written
-   * via `ctx.set` anyway, so an empty answer is the truthful one.
-   */
-  private metadataReadOnly;
-  /**
-   * Write-side accessor for the per-request metadata map.
-   *
-   * Returns the same map as {@link metadataReadOnly} when an ALS frame
-   * is active. Throws otherwise — writing to a fallback map outside
-   * the ALS frame would silently lose data because other call sites
-   * (downstream contributors, request-logger, etc.) read from the
-   * canonical store and would never see it. Mount
-   * `requestScopeMiddleware()` (Application does this for you in
-   * `'auto'` mode) or wrap your test setup in
-   * `requestStore.run({...}, () => …)` to fix.
-   */
-  private metadataForWrite;
-  /**
-   * Parsed request body. Wrapped in a dev-only Proxy that warns when
-   * adopters try to mutate Zod-validated payloads in place — compute
-   * new values and stash them via `ctx.set('key', value)` or a Context
-   * Contributor instead. Reach for `ctx.req.body` if you genuinely
-   * need the raw, mutable Express handle (rare).
-   *
-   * In production the Proxy is bypassed and `this.req.body` is
-   * returned as-is — no runtime cost on the hot path.
-   */
-  get body(): TBody;
-  /** Path parameters parsed from the route — read-only, see {@link body}. */
-  get params(): TParams;
-  /** Parsed query string — read-only, see {@link body}. */
-  get query(): TQuery;
-  /** Inbound HTTP headers — read-only, see {@link body}. */
-  get headers(): Request['headers'];
-  get requestId(): string | undefined;
-  /**
-   * `AbortSignal` that fires when the underlying HTTP request is
-   * closed — either because the client disconnected before the
-   * response was sent, or because Node's socket-close event ran
-   * after a normal response. Multiple `RequestContext` wrappers for
-   * the same request (router-builder constructs one per
-   * middleware/contributor pipeline / main handler) share a single
-   * `AbortController` cached on the underlying `req` object, so the
-   * signal is stable across the request lifecycle.
-   *
-   * Thread it through anything that takes an `AbortSignal` so the
-   * work cancels as soon as the client gives up — e.g. a kickjs-db
-   * relational query:
-   *
-   * ```ts
-   * @Get('/:id/full')
-   * async show(ctx: RequestContext) {
-   *   const row = await this.repo.findFullById(ctx.params.id, ctx.signal)
-   *   if (!row) return ctx.notFound()
-   *   ctx.json(row)
-   * }
-   * ```
-   *
-   * The repo passes `signal` to `db.query.<table>.findUnique({ signal })`;
-   * if the client disconnects mid-flight, the in-flight query rejects
-   * with `RelationalQueryCancelledError` instead of consuming the
-   * connection until completion.
-   *
-   * Implementation note — both `req.on('close')` and `res.on('close')`
-   * are wired so the signal aborts regardless of whether the close
-   * event lands on the request stream or the response stream first.
-   * Subsequent fires are no-ops (`AbortController.abort()` is
-   * idempotent).
-   */
-  get signal(): AbortSignal;
-  /** Session data (requires session middleware) */
-  get session(): any;
-  /**
-   * The authenticated user set by AuthAdapter.
-   * Reads from the per-request metadata store first (`ctx.set('user', ...)`),
-   * then falls back to `req.user` (set directly by AuthAdapter middleware).
-   *
-   * Extend the `AuthUser` interface via module augmentation in `@forinda/kickjs-auth`
-   * to get full typing.
-   *
-   * @example
-   * ```ts
-   * @Get('/me')
-   * @Authenticated()
-   * getProfile(ctx: RequestContext) {
-   *   const user = ctx.user
-   *   if (!user) return ctx.notFound()
-   *   return ctx.json({ user })
-   * }
-   * ```
-   */
-  get user(): MetaValue<'user', Record<string, any>> | undefined;
-  /**
-   * Tenant identifier for multi-tenant apps. Reads `user.tenantId` —
-   * populated either by `AuthAdapter.testMode({ tenantId })`, a tenant
-   * resolver middleware, or manually on the strategy's `mapPayload`.
-   *
-   * Augment `AuthUser` (or `ContextMeta['user']`) to widen the return
-   * type if your user shape guarantees a non-`string | undefined` id.
-   */
-  get tenantId(): string | undefined;
-  /**
-   * Effective role list for the current user. Prefers `user.tenantRoles`
-   * (populated by `AuthAdapterOptions.roleResolver` under a tenant) and
-   * falls back to `user.roles`. Returns an empty array when the user is
-   * absent or the shape has neither field.
-   */
-  get roles(): string[];
-  /**
-   * Parse the request query string into structured filters, sort, pagination, and search.
-   * Pass the result to an ORM query builder adapter (Drizzle, Prisma, Sequelize, etc.).
-   *
-   * Generic over the field config: when passed an inline literal (or
-   * `as const`), `filters[].field` and `sort[].field` are narrowed to
-   * the exact whitelisted field names. Pass nothing or a non-literal
-   * config and you get the loose `string` fallback.
-   *
-   * @param fieldConfig - Optional whitelist for filterable, sortable, and searchable fields
-   * @param options - Limits (`maxLimit`, `defaultLimit`, `maxSearchLength`) and an
-   *   `onReject` hook. By default a rejected/over-broad field is logged via
-   *   `console.warn` with the request id; pass an explicit `onReject` to override
-   *   (e.g. throw to return a 400), or `onReject: () => {}` to silence.
-   *
-   * @example
-   * ```ts
-   * @Get('/')
-   * async list(ctx: RequestContext) {
-   *   const parsed = ctx.qs({
-   *     filterable: ['status', 'priority'],
-   *     sortable: ['createdAt', 'title'],
-   *   } as const)
-   *   parsed.filters[0].field // typed as 'status' | 'priority'
-   *   parsed.sort[0].field    // typed as 'createdAt' | 'title'
-   * }
-   * ```
-   */
-  qs<TConfig extends QueryFieldConfig | undefined = undefined>(fieldConfig?: TConfig, options?: ParseQueryOptions): TypedParsedQuery<TConfig>;
-  /**
-   * Single uploaded file (requires `@FileUpload({ mode: 'single' })`).
-   * Wrapped in a dev-only Proxy that warns on mutation — see {@link body}.
-   * File metadata is set by the upload middleware and shouldn't be
-   * mutated downstream.
-   */
-  get file(): Express.Multer.File | undefined;
-  /**
-   * Array of uploaded files (requires `@FileUpload({ mode: 'array' })`).
-   * The array (and each entry in dev) is wrapped in a read-only Proxy
-   * that warns on `push`/`pop` and per-file mutation. Use
-   * `ctx.req.files` if you genuinely need the mutable Express handle.
-   */
-  get files(): Express.Multer.File[] | undefined;
-  /**
-   * Read a value from the per-request metadata store.
-   *
-   * When `ContextMeta` has been augmented with a matching key, the return
-   * type is inferred automatically. For ad-hoc keys, pass a generic:
-   * `ctx.get<MyType>('custom')`.
-   */
-  get<K extends string>(key: K): MetaValue<K> | undefined;
-  /**
-   * Write a value to the per-request metadata store. Throws when no
-   * AsyncLocalStorage frame is active — see {@link metadataForWrite}
-   * for why a silent fallback is the wrong default.
-   */
-  set<K extends string>(key: K, value: MetaValue<K>): void;
-  json(data: any, status?: number): Response<any, Record<string, any>>;
-  created(data: any): Response<any, Record<string, any>>;
-  noContent(): Response<any, Record<string, any>>;
-  /**
-   * @deprecated Prefer {@link ProblemSender.notFound | ctx.problem.notFound()},
-   * which emits an RFC 9457 — Problem Details response. This helper stays
-   * for backward compatibility and will not be removed.
-   */
-  notFound(message?: string): Response<any, Record<string, any>>;
-  /**
-   * @deprecated Prefer {@link ProblemSender.badRequest | ctx.problem.badRequest()},
-   * which emits an RFC 9457 — Problem Details response. This helper stays
-   * for backward compatibility and will not be removed.
-   */
-  badRequest(message: string): Response<any, Record<string, any>>;
-  /**
-   * RFC 9457 — Problem Details for HTTP APIs response helper.
-   * https://datatracker.ietf.org/doc/html/rfc9457
-   *
-   * `ctx.problem(...)` sends a canonical problem-detail response with
-   * `Content-Type: application/problem+json`. The convenience methods
-   * (`ctx.problem.notFound`, `.badRequest`, etc.) pre-fill `status` +
-   * `title` for the common codes.
-   *
-   * `type` defaults to `about:blank` (§3.1.1); `title` defaults to the
-   * IANA reason phrase for `status` (§3.1.4). Extension members per §3.2
-   * pass through unchanged.
-   *
-   * @example
-   * ```ts
-   * ctx.problem({
-   *   type: 'https://api.example.com/problems/out-of-credit',
-   *   status: 403,
-   *   detail: 'Your balance is 30, but that costs 50.',
-   *   instance: `/account/${ctx.user.id}/messages/${ctx.params.id}`,
-   *   balance: 30,
-   * })
-   *
-   * ctx.problem.notFound({ detail: 'User abc not found' })
-   * ctx.problem.validation(zodResult.error.issues)
-   * ```
-   *
-   * @see {@link ProblemException} for the exception-throwing equivalent
-   * (use it from services where `ctx` isn't in scope).
-   */
-  get problem(): ProblemSender;
-  private sendProblem;
-  html(content: string, status?: number): Response<any, Record<string, any>>;
-  download(buffer: Buffer, filename: string, contentType?: string): Response<any, Record<string, any>>;
-  /**
-   * Render a template using the registered view engine (EJS, Pug, Handlebars, etc.).
-   * Requires a ViewAdapter to be configured in bootstrap().
-   *
-   * @param template - Template name (without extension, relative to viewsDir)
-   * @param data - Data to pass to the template
-   *
-   * @example
-   * ```ts
-   * ctx.render('dashboard', { user, title: 'Dashboard' })
-   * ctx.render('emails/welcome', { name: 'Alice' })
-   * ```
-   */
-  render(template: string, data?: Record<string, any>): void;
-  /**
-   * Parse query params and return a standardized paginated response.
-   * Calls `ctx.qs()` internally, then wraps your data with pagination meta.
-   *
-   * @param fetcher - Async function that receives ParsedQuery and returns `{ data, total }`
-   * @param fieldConfig - Optional whitelist for filterable, sortable, searchable fields
-   *
-   * @example
-   * ```ts
-   * @Get('/')
-   * async list(ctx: RequestContext) {
-   *   return ctx.paginate(
-   *     async (parsed) => {
-   *       const data = await db.select().from(users)
-   *         .where(query.where).limit(parsed.pagination.limit)
-   *         .offset(parsed.pagination.offset).all()
-   *       const total = await db.select({ count: count() }).from(users).get()
-   *       return { data, total: total?.count ?? 0 }
-   *     },
-   *     { filterable: ['name', 'role'], sortable: ['createdAt'] },
-   *   )
-   * }
-   * ```
-   */
-  paginate<T, TConfig extends QueryFieldConfig | undefined = undefined>(fetcher: (parsed: TypedParsedQuery<TConfig>) => Promise<{
-    data: T[];
-    total: number;
-  }>, fieldConfig?: TConfig): Promise<Response<any, Record<string, any>>>;
-  /**
-   * Start an SSE (Server-Sent Events) stream.
-   * Sets the correct headers and returns helpers to send events.
-   *
-   * @example
-   * ```ts
-   * @Get('/events')
-   * async stream(ctx: RequestContext) {
-   *   const sse = ctx.sse()
-   *
-   *   const interval = setInterval(() => {
-   *     sse.send({ time: new Date().toISOString() }, 'tick')
-   *   }, 1000)
-   *
-   *   sse.onClose(() => clearInterval(interval))
-   * }
-   * ```
-   */
-  sse(): {
-    /** Send an SSE event with optional event name and id */send: (data: any, event?: string, id?: string) => void; /** Send a comment (keeps connection alive) */
-    comment: (text: string) => void; /** Register a callback when the client disconnects */
-    onClose: (fn: () => void) => void; /** End the SSE stream */
-    close: () => void;
-  };
-}
-/**
- * Short alias for `RequestContext` parameterised by a route shape.
- *
- * Use with `kick typegen`'s generated `KickRoutes` namespace for
- * fully-typed `ctx.params`, `ctx.body`, and `ctx.query`. Metadata
- * typing (`ctx.get()`, `ctx.set()`, `ctx.user`) comes from
- * `ContextMeta` augmentation and works on all `RequestContext` instances.
- *
- * @example
- * ```ts
- * @Get('/:id')
- * getUser(ctx: Ctx<KickRoutes.UserController['getUser']>) {
- *   ctx.params.id      // typed from RouteShape
- *   ctx.body           // typed from RouteShape
- *   ctx.user           // typed from ContextMeta
- *   ctx.get('tenant')  // typed from ContextMeta
- * }
- * ```
- */
-type Ctx<TRoute extends RouteShape = RouteShape> = RequestContext<TRoute extends {
-  body: infer B;
-} ? B : any, TRoute extends {
-  params: infer P;
-} ? P : any, TRoute extends {
-  query: infer Q;
-} ? Q : any>;
-/**
- * Global ambient registry of typed routes, populated by `kick typegen`.
- *
- * Each interface inside `KickRoutes` corresponds to a controller class;
- * each property is one route method on that controller. The values
- * conform to `RouteShape`.
- *
- * Empty by default — declarations come from `.kickjs/types/routes.d.ts`
- * generated alongside the rest of the typegen output.
- */
-declare global {
-  namespace KickRoutes {}
-} //# sourceMappingURL=context.d.ts.map
-//#endregion
-export { RouteShape as i, DeepReadonly as n, RequestContext as r, Ctx as t };
-//# sourceMappingURL=context-DV7RjM9F.d.mts.map

package/dist/context-DV7RjM9F.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-DV7RjM9F.d.mts","names":[],"sources":["../src/http/context.ts"],"mappings":"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"}

package/dist/context-decorator-DDZ30BIW.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-decorator-DDZ30BIW.d.mts","names":[],"sources":["../src/core/context-decorator.ts"],"mappings":"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"}

package/dist/errors-CRCTjEUK.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-CRCTjEUK.d.mts","names":[],"sources":["../src/core/errors.ts"],"mappings":"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"}

package/dist/execution-context-B4cfhivz.d.mts

@@ -1,98 +0,0 @@
-
-//#region src/core/execution-context.d.ts
-/**
- * Transport-agnostic execution context primitives.
- *
- * `ExecutionContext` is the minimal contract every transport-specific
- * context object satisfies — `RequestContext` (HTTP) implements it today;
- * `WsContext`, `QueueContext`, and `CronContext` will adopt it in V2.
- *
- * `ContextMeta` is the augmentable per-request key/type registry. Apps and
- * plugins extend it via module augmentation to get type-safe `ctx.get/set`
- * across the codebase. It lives in core/ (not http/) so non-HTTP transports
- * share a single declaration site.
- *
- * @example
- * ```ts
- * declare module '@forinda/kickjs' {
- *   interface ContextMeta {
- *     user: { id: string; email: string }
- *     tenant: { id: string; name: string }
- *   }
- * }
- *
- * function loadProject(ctx: ExecutionContext) {
- *   const user = ctx.get('user')   // typed: { id: string; email: string } | undefined
- * }
- * ```
- */
-/**
- * Augmentable per-request **value-type** registry.
- *
- * Extend via module augmentation to give `ctx.get()` / `ctx.set()` static
- * type information for a given key. Unknown keys still resolve via an
- * explicit generic: `ctx.get<MyType>('custom')`.
- *
- * ```ts
- * declare module '@forinda/kickjs' {
- *   interface ContextMeta {
- *     tenant: { id: string; name: string }
- *   }
- * }
- * ```
- *
- * Every key declared here is automatically a valid `dependsOn` key — see
- * {@link ContextKeys} for the relationship.
- */
-interface ContextMeta {}
-/**
- * Augmentable per-request **key** registry — the set of context keys a
- * project's contributors populate, independent of whether each key has a
- * declared value type in {@link ContextMeta}.
- *
- * This exists so `dependsOn` (and any other key-level typing) can be
- * narrowed to real keys WITHOUT forcing every key to carry a value type.
- * Before it, `dependsOn` was typed against `keyof ContextMeta` alone, so
- * the moment a project augmented `ContextMeta` for *some* keys, any
- * contributor that depended on a key you hadn't added to `ContextMeta`
- * stopped compiling — even though that key was a perfectly valid
- * contributor. Splitting the two registries removes that coupling:
- *
- * - Put a key in `ContextMeta` when you want `ctx.get(key)` typed.
- * - Put a key in `ContextKeys` when it's a real contributor key but you
- *   don't need a value type for it (e.g. a marker, or a value you only
- *   ever read with an explicit generic).
- *
- * Keys from BOTH registries are accepted by `dependsOn`, so adding a
- * value type via `ContextMeta` never breaks a `dependsOn` elsewhere.
- *
- * ```ts
- * declare module '@forinda/kickjs' {
- *   interface ContextKeys {
- *     session: true       // value type irrelevant; the key just exists
- *   }
- * }
- * ```
- */
-interface ContextKeys {}
-/** Resolve a {@link ContextMeta} value type, falling back to `Fallback` for unknown keys. */
-type MetaValue<K extends string, Fallback = unknown> = K extends keyof ContextMeta ? ContextMeta[K] : Fallback;
-/**
- * Minimal transport-agnostic execution context.
- *
- * `RequestContext` (HTTP) implements this directly; future `WsContext`,
- * `QueueContext`, and `CronContext` (V2) will too. The Context Contributor
- * pipeline only depends on this interface — contributors authored against
- * `ExecutionContext` work across every transport that adopts it.
- */
-interface ExecutionContext {
-  /** Read a typed value from per-request metadata. */
-  get<K extends string>(key: K): MetaValue<K> | undefined;
-  /** Write a typed value into per-request metadata. */
-  set<K extends string>(key: K, value: MetaValue<K>): void;
-  /** Unique per-request identifier (HTTP: x-request-id; WS/queue/cron: transport-defined). */
-  readonly requestId: string | undefined;
-}
-//#endregion
-export { MetaValue as i, ContextMeta as n, ExecutionContext as r, ContextKeys as t };
-//# sourceMappingURL=execution-context-B4cfhivz.d.mts.map

package/dist/execution-context-B4cfhivz.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"execution-context-B4cfhivz.d.mts","names":[],"sources":["../src/core/execution-context.ts"],"mappings":";;;AA8CA;;;;AAA4B;AAgC5B;;;;AAA4B;AAG5B;;;;;;;;;;;;;;;;;;AAEY;AAUZ;;;;;;;;;;;;;;UA/CiB,WAAA;;;;;;;;;;;AAqDG;;;;;;;;;;;;;;;;;;;UArBH,WAAA;;KAGL,SAAA,yCAAkD,CAAA,eAAgB,WAAA,GAC1E,WAAA,CAAY,CAAA,IACZ,QAAA;;;;;;;;;UAUa,gBAAA;;EAEf,GAAA,mBAAsB,GAAA,EAAK,CAAA,GAAI,SAAA,CAAU,CAAA;;EAEzC,GAAA,mBAAsB,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,SAAA,CAAU,CAAA;;WAEtC,SAAA;AAAA"}