@nwire/handler 0.8.0 → 0.9.1

package/README.md

@@ -1,88 +1,203 @@
 # @nwire/handler
 
-> Operation primitive — one shape for action / query / resolver, usable from any transport.
-
-`defineHandler(name, config)` describes a single operation: input
-schema, response shape, the function. `execute(handler, input, ctx?)`
-runs one. Every Nwire transport (`@nwire/http`, `@nwire/queue`,
-`@nwire/mcp`) speaks this exact shape; `@nwire/forge`'s `defineAction`
-and `defineQuery` are flavored sugar on top.
+The operation primitive — one typed, callable, hookable value usable from every transport (HTTP, queue, MCP, CLI, direct test).
 
 ```bash
-pnpm add @nwire/handler zod
+pnpm add @nwire/handler
+```
+
+## Why
+
+Every backend ends up with the same shape: parse input, run a function with some deps, return a typed response or throw a typed error. Different teams wrap it in different abstractions (controllers, route handlers, command handlers, tRPC procedures, NestJS providers). They're all the same thing.
+
+`@nwire/handler` is that thing, distilled: a callable, type-generic value. It's a `Hook` from `@nwire/hooks` underneath, so it gets `.use()` middleware, `.on()` listeners, `.tap()` observation, `signal` cancellation, and replay — for free.
+
+Three rules:
+
+1. **Ctx is generic.** Whatever you pass to `.run(ctx)` is what the handler body destructures, fully typed.
+2. **App pins ctx once.** `defineHandlerWith<AppExtras>()` returns a factory you import everywhere; handlers never annotate ctx.
+3. **No global pollution.** Plugin contributions are imported types, intersected at the app boundary. Nothing is `declare module`-ed.
+
+## Surface
+
+```ts
+// The primitive
+function defineHandler<TInputSchema, TOutput, TExtras extends object = object>(
+  name: string,
+  config: HandlerConfig<TInputSchema, TOutput, TExtras>,
+): HandlerDefinition<TInputSchema, TOutput, TExtras>;
+
+// The app-boundary factory — pins TExtras once
+function defineHandlerWith<TExtras extends object>(): typeof defineHandler bound to TExtras;
+
+// Type alias for declaring a handler's ctx shape inline
+type Ctx<TInput, TExtras extends object = object> =
+  { input: TInput; signal: AbortSignal; set: …  } & TExtras;
+
+// Resources, errors, response factories
+function defineResource(name, { schema, public, examples });
+function defineError({ code, status, summary });   // callable: throw NotFound({ resourceId });
+ok / created / accepted / noContent / notModified / gone
+
+// Built-in errors
+Unauthorized / Forbidden / NotFound / Conflict / Gone / BadRequest
+
+// Type helpers
+HandlerInput<H> / HandlerOutput<H> / HandlerExtras<H>
 ```
 
-## Quick example
+## Consumer example
+
+`app/define.ts` — one file, pinned once:
+
+```ts
+import { defineHandlerWith, type Ctx } from "@nwire/handler";
+import type { AuthCradle } from "@nwire/auth";
+import type { DbCradle } from "@nwire/data-drizzle";
+
+// Plugins export type fragments; app composes its cradle:
+export type AppCradle = AuthCradle &
+  DbCradle & {
+    config: AppConfig;
+    logger: Logger;
+  };
+
+// Extras the wires put onto ctx at request time:
+type AppExtras = {
+  logger: Logger;
+  pg: PgClient;
+  user: { id: string; role: string; balance: number };
+};
+
+export const defineAction = defineHandlerWith<AppExtras>();
+export type AppCtx<I = unknown> = Ctx<I, AppExtras>;
+```
+
+`app/orders/buy-wash.action.ts` — a complete handler:
 
 ```ts
 import { z } from "zod";
-import {
-  defineHandler,
-  defineMiddleware,
-  defineHook,
-  pipe,
-  execute,
-  NotFound,
-  ok,
-} from "@nwire/handler";
-
-const authenticate = defineMiddleware("authenticate", async (ctx, next) => {
-  ctx.user = await verifyToken(ctx.header("authorization"));
+import { defineResource, defineError, NotFound } from "@nwire/handler";
+import { defineAction } from "@/define";
+
+const Wash = defineResource("Wash", {
+  schema: z.object({ id: z.string(), name: z.string(), price: z.number() }),
+  public: ["id", "name", "price"],
+});
+
+const InsufficientFunds = defineError({
+  code: "INSUFFICIENT_FUNDS",
+  status: 402,
+  summary: "balance too low for this wash",
+});
+
+export const BuyWash = defineAction("buyWash", {
+  input: z.object({ washId: z.string() }),
+  returns: Wash,
+  errors: [NotFound, InsufficientFunds],
+  handler: async ({ input, logger, pg, user, signal }) => {
+    const row = await pg.query("SELECT * FROM washes WHERE id=$1", [input.washId], { signal });
+    if (!row) throw NotFound({ resourceId: input.washId });
+    if (user.balance < row.price) throw InsufficientFunds({ have: user.balance, need: row.price });
+    logger.log(`${user.id} bought ${row.id}`);
+    return row;
+  },
+});
+
+// Per-handler middleware via the hook substrate
+BuyWash.use(async (ctx, next) => {
+  const t = performance.now();
   await next();
+  ctx.logger.log(`buyWash ${(performance.now() - t).toFixed(1)}ms`);
 });
+```
 
-const auditLog = defineHook("after", "audit", async (ctx, result) => {
-  await audit.write({ user: ctx.user.id, result });
+`wires/api.wire.ts` — boot, container, request composition:
+
+```ts
+import { createContainer } from "@nwire/container";
+import type { AppCradle } from "@/define";
+import { BuyWash } from "@/orders/buy-wash.action";
+
+const root = createContainer<AppCradle>();
+root.register("config", { port: 3000 });
+root.register("logger", () => ({ log: (s) => console.log(s) }));
+root.register("db.pg", () => new PgClient(root.cradle.config.port));
+
+const server = createServer(async (req, res) => {
+  const user = await authenticate(req);
+
+  const result = await BuyWash(JSON.parse(await readBody(req))).run({
+    ctx: {
+      logger: root.cradle.logger,
+      pg: root.cradle["db.pg"],
+      user,
+    },
+    signal: req.signal,
+  });
+  res.writeHead(201).end(JSON.stringify(result));
 });
+```
 
-const userPipeline = pipe("user-pipeline", authenticate, auditLog);
+`app/orders/buy-wash.test.ts` — unit test, no container:
 
-const getUser = defineHandler("getUser", {
-  input:   z.object({ id: z.string() }),
-  middleware: [userPipeline],
-  handler: async ({ input, resolve }) => {
-    const repo = resolve<UserRepo>("UserRepo");
-    const user = await repo.findById(input.id);
-    if (!user) throw NotFound("user", input.id);
-    return ok(user);
-  },
+```ts
+import { expect, test } from "vitest";
+import { BuyWash, InsufficientFunds } from "./buy-wash.action";
+
+test("rejects when balance < price", async () => {
+  await expect(
+    BuyWash({ washId: "w1" }).run({
+      ctx: {
+        logger: { log: () => {} },
+        pg: { query: async () => ({ id: "w1", name: "Quick", price: 100 }) },
+        user: { id: "u-1", role: "user", balance: 5 },
+      },
+    }),
+  ).rejects.toMatchObject({
+    code: "INSUFFICIENT_FUNDS",
+    status: 402,
+    context: { have: 5, need: 100 },
+  });
 });
+```
+
+## The four contracts in one model
+
+| Concern          | How                                                                                         |
+| ---------------- | ------------------------------------------------------------------------------------------- |
+| Input validation | `input: zodSchema` — parsed before the handler body runs                                    |
+| Output shape     | `returns: Resource \| ResponseSpec[]` — narrows the handler's return type, drives OpenAPI   |
+| Throws           | `errors: [NotFound, …]` — typed throwables, drive 4xx OpenAPI bodies                        |
+| Cancellation     | `signal: AbortSignal` on ctx — forward to fetch/pg/etc., bail via `signal.throwIfAborted()` |
+
+## Cancellation in practice
 
-const res = await execute(getUser, { id: "u_1" }, { resolve });
+The signal flows through nested `.run()` calls automatically:
+
+```ts
+const ParentOp = defineAction("parent", {
+  handler: async ({ signal }) => ChildOp().run({ signal }),
+});
+// caller-supplied signal → ParentOp.run({ signal }) → ChildOp.run({ signal })
+// abort the caller's controller → both bail
 ```
 
-## Surface
+When no signal is supplied, ctx gets a non-aborting placeholder — code can always pass `ctx.signal` through to `fetch`/`pg`/`redis` without null checks.
+
+## Errors
+
+```ts
+throw NotFound; // bare value (it IS an Error)
+throw NotFound({ resourceId: input.id }); // callable, contextualised clone
+```
+
+Caught at the transport layer — REST → `status` + `{ code, message, context }`, GraphQL → `extensions.code`, CLI → exit status + stderr.
+
+## Built on @nwire/hooks
+
+Every handler is a `Hook<HandlerRunCtx>` underneath. `.use()`, `.on()`, `.tap()`, `.runDetailed()` all work. The user's handler function is the innermost chain step, registered at construction with `Number.MIN_SAFE_INTEGER` priority so every `.use()` you add wraps around it. Telemetry, replay, observation come along for free.
+
+## Scope
 
-| Export                              | Role                                                            |
-| ----------------------------------- | --------------------------------------------------------------- |
-| `defineHandler(name, config)`       | The operation primitive: `{ input, handler, returns?, errors?, summary?, policy?, middleware? }`. |
-| `execute(handler, input, ctx?)`     | Run one handler; returns a response envelope.                   |
-| `defineMiddleware(name?, fn)`       | Chain step `(ctx, next)`. Captures `$source`. Reusable.         |
-| `defineHook("before" \| "after", name?, fn)` | Before-or-after-only step (cleaner than mw that forgets `next()`). |
-| `pipe(name?, ...steps)`             | Compose middleware + hooks into a reusable pipe value. Attaches a per-pipe `$hook` (`@nwire/hooks`) so transports adopt it for telemetry. |
-| `unwindPipe(steps)`                 | Walk a pipe into `{ middlewares, beforeHooks, afterHooks }` — transports call this when mounting. |
-| `defineResource(name, opts)`        | Public response shape (field allowlist, OpenAPI schema).        |
-| `defineError(meta)`                 | Typed throwable with status code.                               |
-| Response factories                  | `ok` / `created` / `accepted` / `noContent` / `notModified` / `gone`. |
-| Framework errors                    | `Unauthorized` / `Forbidden` / `NotFound` / `Conflict` / `Gone` / `BadRequest`. |
-| Type guards                         | `isHandlerDefinition` / `isMiddleware` / `isHook` / `isPipe` / `isResourceDefinition` / `isNwireError` / `isResponseSpec` / `isResponseInstance`. |
-
-### `$source` + `$hook`
-
-- Every `defineMiddleware` / `pipe` captures its call site as `$source`
-  via `@nwire/messages.captureSourceLocation`, so Studio can render
-  click-to-open chips.
-- Every `pipe(...)` creates a per-pipe `Hook<ResolverCtx>` (one
-  `.use()` per middleware step). Runtimes adopt it via
-  `runtime.adoptHook($hook)` to route taps into telemetry; consumers
-  that don't know about `$hook` ignore the field.
-
-## Related
-
-- `@nwire/forge` — re-exports this surface and layers `defineAction` (`defineHandler` + `emits`) + `defineQuery` on top.
-- `@nwire/hooks` — backs `pipe()`'s per-pipe `$hook` and the resolver-level dispatch chain.
-- `@nwire/http` — mounts handlers by `unwindPipe`-ing their middleware.
-
-## Status
-
-v0.x — handler shape, middleware/hook/pipe primitives, response factories, and core errors are locked. Per-pipe `$hook` adoption is the canonical observation seam.
+Standalone — no DI, no events, no logger, no transport opinions. App composes ctx by value; transports compose ctx at boot. Forge / HTTP / queue / MCP wires layer on top.

package/dist/define-error.d.ts

@@ -7,14 +7,20 @@
  *     summary: "Station already has an unfinished wash",
  *   });
  *
- *   // In a resolver handler:
- *   if (active) throw WashInProgress;
+ *   // Throw it with context — callable form, symmetric with defineEvent/defineAction:
+ *   throw WashInProgress({ stationId: input.id });
  *
- * Each call site reuses the SAME instance (immutable). Transports detect
- * `instanceof NwireError`, read `.code` + `.status` + `.summary`, render
- * the right shape per medium:
- *   - REST     → JSON body `{ code, message }` with the declared status
- *   - GraphQL  → error with `extensions: { code }`
+ *   // Throw it without context — works because the definition IS an Error:
+ *   throw WashInProgress;
+ *
+ * Each `defineError(...)` result is BOTH:
+ *   - an `Error` instance you can `throw` directly (zero context),
+ *   - a callable factory `Boom(context)` that returns a contextualised clone.
+ *
+ * Transports detect `instanceof NwireError`, read `.code` + `.status` + `.summary`
+ * + `.context`, render the right shape per medium:
+ *   - REST     → JSON body `{ code, message, context }` with the declared status
+ *   - GraphQL  → error with `extensions: { code, context }`
  *   - CLI      → stderr message + exit status
  */
 export interface ErrorMeta {
@@ -24,36 +30,36 @@ export interface ErrorMeta {
     readonly description?: string;
     readonly tags?: readonly string[];
 }
-export interface ErrorDefinition extends ErrorMeta {
-    readonly $kind: "error";
-}
 /**
  * Concrete Error subclass — thrown by domain code, caught by transport.
- * The `defineError(...)` result is an instance of this class.
+ * The `defineError(...)` result is an instance of this class, AND callable
+ * so `Boom(context)` returns a contextualised clone.
  */
-export declare class NwireError extends Error implements ErrorDefinition {
+export declare class NwireError extends Error implements ErrorMeta {
     readonly $kind: "error";
     readonly code: string;
     readonly status: number;
     readonly summary: string;
     readonly description?: string;
     readonly tags?: readonly string[];
-    constructor(meta: ErrorMeta);
-    /**
-     * Build a fresh error instance with the same metadata but additional
-     * runtime context — e.g., the resource id that triggered it.
-     */
-    with(context: Record<string, unknown>): NwireError & {
-        readonly context: Record<string, unknown>;
-    };
+    readonly context?: Readonly<Record<string, unknown>>;
+    constructor(meta: ErrorMeta, context?: Readonly<Record<string, unknown>>);
+}
+/**
+ * The value returned by `defineError(meta)` — callable to build a contextual
+ * clone, and itself an Error instance you can throw directly.
+ */
+export interface ErrorDefinition extends NwireError {
+    /** Build a contextualised clone — `throw NotFound({ resourceId: id })`. */
+    (context: Readonly<Record<string, unknown>>): NwireError;
 }
-export declare function defineError(meta: ErrorMeta): NwireError;
+export declare function defineError(meta: ErrorMeta): ErrorDefinition;
 /** Type narrow. */
 export declare function isNwireError(x: unknown): x is NwireError;
-export declare const Unauthorized: NwireError;
-export declare const Forbidden: NwireError;
-export declare const NotFound: NwireError;
-export declare const Gone: NwireError;
-export declare const BadRequest: NwireError;
-export declare const Conflict: NwireError;
+export declare const Unauthorized: ErrorDefinition;
+export declare const Forbidden: ErrorDefinition;
+export declare const NotFound: ErrorDefinition;
+export declare const Gone: ErrorDefinition;
+export declare const BadRequest: ErrorDefinition;
+export declare const Conflict: ErrorDefinition;
 //# sourceMappingURL=define-error.d.ts.map

package/dist/define-error.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"define-error.d.ts","sourceRoot":"","sources":["../src/define-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED,MAAM,WAAW,eAAgB,SAAQ,SAAS;IAChD,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CAKzB;AAED;;;GAGG;AACH,qBAAa,UAAW,SAAQ,KAAM,YAAW,eAAe;IAC9D,QAAQ,CAAC,KAAK,EAAG,OAAO,CAAU;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;gBAEtB,IAAI,EAAE,SAAS;IAU3B;;;OAGG;IACH,IAAI,CACF,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC/B,UAAU,GAAG;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE;CAK9D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,UAAU,CAEvD;AAED,mBAAmB;AACnB,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU,CAExD;AAGD,eAAO,MAAM,YAAY,YAIvB,CAAC;AAEH,eAAO,MAAM,SAAS,YAIpB,CAAC;AAEH,eAAO,MAAM,QAAQ,YAInB,CAAC;AAEH,eAAO,MAAM,IAAI,YAIf,CAAC;AAEH,eAAO,MAAM,UAAU,YAIrB,CAAC;AAEH,eAAO,MAAM,QAAQ,YAInB,CAAC"}
+{"version":3,"file":"define-error.d.ts","sourceRoot":"","sources":["../src/define-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAED;;;;GAIG;AACH,qBAAa,UAAW,SAAQ,KAAM,YAAW,SAAS;IACxD,QAAQ,CAAC,KAAK,EAAG,OAAO,CAAU;IAClC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAClC,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;gBAEzC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAUzE;AAED;;;GAGG;AACH,MAAM,WAAW,eAAgB,SAAQ,UAAU;IACjD,2EAA2E;IAC3E,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAAG,UAAU,CAAC;CAC1D;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,CAW5D;AAED,mBAAmB;AACnB,wBAAgB,YAAY,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,UAAU,CAExD;AAGD,eAAO,MAAM,YAAY,iBAIvB,CAAC;AAEH,eAAO,MAAM,SAAS,iBAIpB,CAAC;AAEH,eAAO,MAAM,QAAQ,iBAInB,CAAC;AAEH,eAAO,MAAM,IAAI,iBAIf,CAAC;AAEH,eAAO,MAAM,UAAU,iBAIrB,CAAC;AAEH,eAAO,MAAM,QAAQ,iBAInB,CAAC"}

package/dist/define-error.js

@@ -7,19 +7,26 @@
  *     summary: "Station already has an unfinished wash",
  *   });
  *
- *   // In a resolver handler:
- *   if (active) throw WashInProgress;
+ *   // Throw it with context — callable form, symmetric with defineEvent/defineAction:
+ *   throw WashInProgress({ stationId: input.id });
  *
- * Each call site reuses the SAME instance (immutable). Transports detect
- * `instanceof NwireError`, read `.code` + `.status` + `.summary`, render
- * the right shape per medium:
- *   - REST     → JSON body `{ code, message }` with the declared status
- *   - GraphQL  → error with `extensions: { code }`
+ *   // Throw it without context — works because the definition IS an Error:
+ *   throw WashInProgress;
+ *
+ * Each `defineError(...)` result is BOTH:
+ *   - an `Error` instance you can `throw` directly (zero context),
+ *   - a callable factory `Boom(context)` that returns a contextualised clone.
+ *
+ * Transports detect `instanceof NwireError`, read `.code` + `.status` + `.summary`
+ * + `.context`, render the right shape per medium:
+ *   - REST     → JSON body `{ code, message, context }` with the declared status
+ *   - GraphQL  → error with `extensions: { code, context }`
  *   - CLI      → stderr message + exit status
  */
 /**
  * Concrete Error subclass — thrown by domain code, caught by transport.
- * The `defineError(...)` result is an instance of this class.
+ * The `defineError(...)` result is an instance of this class, AND callable
+ * so `Boom(context)` returns a contextualised clone.
  */
 export class NwireError extends Error {
     $kind = "error";
@@ -28,7 +35,8 @@ export class NwireError extends Error {
     summary;
     description;
     tags;
-    constructor(meta) {
+    context;
+    constructor(meta, context) {
         super(meta.summary);
         this.name = meta.code;
         this.code = meta.code;
@@ -36,19 +44,19 @@ export class NwireError extends Error {
         this.summary = meta.summary;
         this.description = meta.description;
         this.tags = meta.tags;
-    }
-    /**
-     * Build a fresh error instance with the same metadata but additional
-     * runtime context — e.g., the resource id that triggered it.
-     */
-    with(context) {
-        const next = new NwireError(this);
-        Object.assign(next, { context });
-        return next;
+        if (context !== undefined)
+            this.context = context;
     }
 }
 export function defineError(meta) {
-    return new NwireError(meta);
+    // Build the canonical (no-context) instance + make it callable.
+    const base = new NwireError(meta);
+    const factory = ((context) => new NwireError(meta, context));
+    // Copy every own property + the prototype-resident fields onto the factory
+    // so `factory instanceof Error`, `factory.code`, `factory.message`, etc.
+    // all behave like the underlying NwireError instance.
+    Object.setPrototypeOf(factory, base);
+    return factory;
 }
 /** Type narrow. */
 export function isNwireError(x) {

package/dist/define-error.js.map

@@ -1 +1 @@
-{"version":3,"file":"define-error.js","sourceRoot":"","sources":["../src/define-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAkBH;;;GAGG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAC1B,KAAK,GAAG,OAAgB,CAAC;IACzB,IAAI,CAAS;IACb,MAAM,CAAS;IACf,OAAO,CAAS;IAChB,WAAW,CAAU;IACrB,IAAI,CAAqB;IAElC,YAAY,IAAe;QACzB,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;IACxB,CAAC;IAED;;;OAGG;IACH,IAAI,CACF,OAAgC;QAEhC,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;QAClC,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC;QACjC,OAAO,IAAkE,CAAC;IAC5E,CAAC;CACF;AAED,MAAM,UAAU,WAAW,CAAC,IAAe;IACzC,OAAO,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;AAC9B,CAAC;AAED,mBAAmB;AACnB,MAAM,UAAU,YAAY,CAAC,CAAU;IACrC,OAAO,CAAC,YAAY,UAAU,CAAC;AACjC,CAAC;AAED,+CAA+C;AAC/C,MAAM,CAAC,MAAM,YAAY,GAAG,WAAW,CAAC;IACtC,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,0BAA0B;CACpC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC;IACnC,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,kDAAkD;CAC5D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC;IAClC,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,+BAA+B;CACzC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAC;IAC9B,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,iDAAiD;CAC3D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,WAAW,CAAC;IACpC,IAAI,EAAE,aAAa;IACnB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,8EAA8E;CACxF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC;IAClC,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,2DAA2D;CACrE,CAAC,CAAC"}
+{"version":3,"file":"define-error.js","sourceRoot":"","sources":["../src/define-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAUH;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IAC1B,KAAK,GAAG,OAAgB,CAAC;IACzB,IAAI,CAAS;IACb,MAAM,CAAS;IACf,OAAO,CAAS;IAChB,WAAW,CAAU;IACrB,IAAI,CAAqB;IACzB,OAAO,CAAqC;IAErD,YAAY,IAAe,EAAE,OAA2C;QACtE,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACpC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,OAAO,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACpD,CAAC;CACF;AAWD,MAAM,UAAU,WAAW,CAAC,IAAe;IACzC,gEAAgE;IAChE,MAAM,IAAI,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,OAAO,GAAoB,CAAC,CAAC,OAA0C,EAAE,EAAE,CAC/E,IAAI,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAA+B,CAAC;IAE/D,2EAA2E;IAC3E,yEAAyE;IACzE,sDAAsD;IACtD,MAAM,CAAC,cAAc,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;IACrC,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,mBAAmB;AACnB,MAAM,UAAU,YAAY,CAAC,CAAU;IACrC,OAAO,CAAC,YAAY,UAAU,CAAC;AACjC,CAAC;AAED,+CAA+C;AAC/C,MAAM,CAAC,MAAM,YAAY,GAAG,WAAW,CAAC;IACtC,IAAI,EAAE,cAAc;IACpB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,0BAA0B;CACpC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,SAAS,GAAG,WAAW,CAAC;IACnC,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,kDAAkD;CAC5D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC;IAClC,IAAI,EAAE,WAAW;IACjB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,+BAA+B;CACzC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,IAAI,GAAG,WAAW,CAAC;IAC9B,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,iDAAiD;CAC3D,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,UAAU,GAAG,WAAW,CAAC;IACpC,IAAI,EAAE,aAAa;IACnB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,8EAA8E;CACxF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,QAAQ,GAAG,WAAW,CAAC;IAClC,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,2DAA2D;CACrE,CAAC,CAAC"}