awaitly 1.34.0 → 2.0.0

package/dist/tagged-error.cjs

@@ -1,2 +0,0 @@
-"use strict";var d=Object.defineProperty;var m=Object.getOwnPropertyDescriptor;var x=Object.getOwnPropertyNames;var h=Object.prototype.hasOwnProperty;var k=(r,e)=>{for(var n in e)d(r,n,{get:e[n],enumerable:!0})},_=(r,e,n,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of x(e))!h.call(r,a)&&a!==n&&d(r,a,{get:()=>e[a],enumerable:!(o=m(e,a))||o.enumerable});return r};var b=r=>_(d({},"__esModule",{value:!0}),r);var H={};k(H,{TaggedError:()=>c});module.exports=b(H);var P={"step-require-id":"step-require-id","step-no-immediate-execution":"step-no-immediate-execution","step-require-thunk-for-key":"step-require-thunk-for-key","step-no-bare-await":"step-no-bare-await","step-no-try-catch-wrap":"step-no-try-catch-wrap","step-stable-cache-keys":"step-stable-cache-keys","workflow-no-floating":"workflow-no-floating","workflow-options-position":"workflow-options-position","workflow-callback-shape":"workflow-callback-shape","workflow-no-callable-form":"workflow-no-callable-form","workflow-no-dynamic-import":"workflow-no-dynamic-import","result-no-floating":"result-no-floating","result-require-handling":"result-require-handling","result-no-double-wrap":"result-no-double-wrap","result-no-manual-propagation":"result-no-manual-propagation","result-no-direct-ok-err":"result-no-direct-ok-err","error-check-unexpected-first":"error-check-unexpected-first","error-access-cause":"error-access-cause","error-normalize":"error-normalize","error-no-throw-in-deps":"error-no-throw-in-deps","concurrency-no-promise-all":"concurrency-no-promise-all","concurrency-no-promise-race":"concurrency-no-promise-race","concurrency-no-promise-allsettled":"concurrency-no-promise-allsettled","runtime-step-timeout":"runtime-step-timeout","runtime-step-aborted":"runtime-step-aborted","runtime-retry-exhausted":"runtime-retry-exhausted","runtime-rate-limit":"runtime-rate-limit","runtime-circuit-open":"runtime-circuit-open","runtime-unexpected":"runtime-unexpected","runtime-resolver-not-found":"runtime-resolver-not-found","runtime-saga-compensation":"runtime-saga-compensation"};function y(r){return`https://jagreehal.github.io/awaitly/rules/#${r}`}var S=Object.keys(P);var u=class extends Error{_tag};function c(r,e){return class extends u{_tag=r;constructor(n,o){let a=e?.message?e.message(n??{}):r;if(super(a),this.name=r,e?.slug!==void 0){if(!e.hint)throw new TypeError(`TaggedError: 'hint' is required when 'slug' is set (slug: "${e.slug}")`);Object.defineProperty(this,"code",{value:e.slug,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"hint",{value:e.hint,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"docsUrl",{value:y(e.slug),enumerable:!0,writable:!1,configurable:!1})}if(Object.setPrototypeOf(this,new.target.prototype),n&&typeof n=="object"){let t;if(e?.slug!==void 0){let{_tag:l,name:f,message:w,stack:E,code:p,hint:O,docsUrl:A,...T}=n;t=T}else{let{_tag:l,name:f,message:w,stack:E,...p}=n;t=p}let s=Object.prototype.hasOwnProperty.call(t,"cause"),g=s?t.cause:void 0;s&&delete t.cause;let i=o?.cause!==void 0;if(s&&i)throw new TypeError("TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause");Object.assign(this,t),s&&(this.cause=g),i&&(this.cause=o?.cause)}else o?.cause!==void 0&&(this.cause=o.cause)}}}Object.defineProperty(c,Symbol.hasInstance,{value:r=>r instanceof u});(a=>{function r(t){return t instanceof Error}a.isError=r;function e(t){return t instanceof u}a.isTaggedError=e;function n(t,s){let g=t._tag,i=s[g];return i(t)}a.match=n;function o(t,s,g){let i=t._tag,l=s[i];return l?l(t):g(t)}a.matchPartial=o})(c||={});0&&(module.exports={TaggedError});
-//# sourceMappingURL=tagged-error.cjs.map

package/dist/tagged-error.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/tagged-error-entry.ts","../src/slugs.ts","../src/tagged-error.ts"],"sourcesContent":["/**\n * awaitly/tagged-error\n *\n * Tagged error classes: type-safe errors with discriminated unions.\n *\n * @example\n * ```typescript\n * import { TaggedError, type TagOf, type PropsOf } from 'awaitly/tagged-error';\n *\n * class UserNotFound extends TaggedError('UserNotFound')<{ userId: string }> {}\n * class InsufficientFunds extends TaggedError('InsufficientFunds', {\n *   message: (p: { required: number; available: number }) =>\n *     `Need ${p.required}, have ${p.available}`,\n * }) {}\n *\n * const error = new UserNotFound({ userId: '123' });\n * error._tag // 'UserNotFound'\n * error.userId // '123'\n * ```\n */\n\nexport {\n  // Factory function\n  TaggedError,\n\n  // Types\n  type TaggedErrorBase,\n  type TaggedErrorOptions,\n  type TaggedErrorCreateOptions,\n  type TaggedErrorConstructor,\n\n  // Type utilities\n  type TagOf,\n  type ErrorByTag,\n  type PropsOf,\n} from \"./tagged-error\";\n","/**\n * awaitly/slugs\n *\n * Source-of-truth slug namespace. Every concept that surfaces as a runtime\n * error, lint rule, static-analyzer diagnostic, visualizer event, or skill rule\n * has exactly one canonical kebab-case slug here.\n *\n * Slugs are public API. Renames are a major version bump. Adds are non-breaking.\n *\n * Categories:\n * - step-*       step() discipline\n * - workflow-*   createWorkflow / run / runWithState shape\n * - result-*     Result usage\n * - error-*      Boundary handling\n * - concurrency-* step.all/map/race vs Promise.*\n * - runtime-*    Failures only observable at runtime\n */\n\nexport const AWAITLY_SLUGS = {\n  // --- step-* ---\n  \"step-require-id\": \"step-require-id\",\n  \"step-no-immediate-execution\": \"step-no-immediate-execution\",\n  \"step-require-thunk-for-key\": \"step-require-thunk-for-key\",\n  \"step-no-bare-await\": \"step-no-bare-await\",\n  \"step-no-try-catch-wrap\": \"step-no-try-catch-wrap\",\n  \"step-stable-cache-keys\": \"step-stable-cache-keys\",\n\n  // --- workflow-* ---\n  \"workflow-no-floating\": \"workflow-no-floating\",\n  \"workflow-options-position\": \"workflow-options-position\",\n  \"workflow-callback-shape\": \"workflow-callback-shape\",\n  \"workflow-no-callable-form\": \"workflow-no-callable-form\",\n  \"workflow-no-dynamic-import\": \"workflow-no-dynamic-import\",\n\n  // --- result-* ---\n  \"result-no-floating\": \"result-no-floating\",\n  \"result-require-handling\": \"result-require-handling\",\n  \"result-no-double-wrap\": \"result-no-double-wrap\",\n  \"result-no-manual-propagation\": \"result-no-manual-propagation\",\n  \"result-no-direct-ok-err\": \"result-no-direct-ok-err\",\n\n  // --- error-* ---\n  \"error-check-unexpected-first\": \"error-check-unexpected-first\",\n  \"error-access-cause\": \"error-access-cause\",\n  \"error-normalize\": \"error-normalize\",\n  \"error-no-throw-in-deps\": \"error-no-throw-in-deps\",\n\n  // --- concurrency-* ---\n  \"concurrency-no-promise-all\": \"concurrency-no-promise-all\",\n  \"concurrency-no-promise-race\": \"concurrency-no-promise-race\",\n  \"concurrency-no-promise-allsettled\": \"concurrency-no-promise-allsettled\",\n\n  // --- runtime-* ---\n  \"runtime-step-timeout\": \"runtime-step-timeout\",\n  \"runtime-step-aborted\": \"runtime-step-aborted\",\n  \"runtime-retry-exhausted\": \"runtime-retry-exhausted\",\n  \"runtime-rate-limit\": \"runtime-rate-limit\",\n  \"runtime-circuit-open\": \"runtime-circuit-open\",\n  \"runtime-unexpected\": \"runtime-unexpected\",\n  \"runtime-resolver-not-found\": \"runtime-resolver-not-found\",\n  \"runtime-saga-compensation\": \"runtime-saga-compensation\",\n} as const;\n\n/** All canonical awaitly slugs as a string-literal union. */\nexport type AwaitlySlug = keyof typeof AWAITLY_SLUGS;\n\n/** Categories derived from slug prefixes. */\nexport type AwaitlySlugCategory =\n  | \"step\"\n  | \"workflow\"\n  | \"result\"\n  | \"error\"\n  | \"concurrency\"\n  | \"runtime\";\n\n/** Returns the category (prefix) of a slug. */\nexport function slugCategory(slug: AwaitlySlug): AwaitlySlugCategory {\n  return slug.split(\"-\")[0] as AwaitlySlugCategory;\n}\n\n/**\n * Returns the canonical docs URL for a slug. Resolves to the matching\n * anchored section on the consolidated rule index page.\n */\nexport function slugDocsUrl(slug: AwaitlySlug): string {\n  return `https://jagreehal.github.io/awaitly/rules/#${slug}`;\n}\n\n/** Type guard: is a string a known awaitly slug? */\nexport function isAwaitlySlug(value: string): value is AwaitlySlug {\n  return Object.prototype.hasOwnProperty.call(AWAITLY_SLUGS, value);\n}\n\n/** All slugs as an array. */\n// Object.keys returns string[] — cast is safe because AWAITLY_SLUGS is `as const`\n// and the module's keys are never mutated.\nexport const ALL_SLUGS: readonly AwaitlySlug[] = Object.keys(\n  AWAITLY_SLUGS\n) as AwaitlySlug[];\n","/**\n * awaitly/tagged-error\n *\n * Factory for creating tagged error types with exhaustive pattern matching.\n * Enables TypeScript to enforce that all error variants are handled.\n *\n * @example\n * ```typescript\n * // Define error types (Props via generic)\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{\n *   id: string;\n *   resource: string;\n * }> {}\n *\n * // Define with type-safe message (Props inferred from callback annotation)\n * class ValidationError extends TaggedError(\"ValidationError\", {\n *   message: (p: { field: string; reason: string }) => `Invalid ${p.field}: ${p.reason}`,\n * }) {}\n *\n * // Create instances\n * const error = new NotFoundError({ id: \"123\", resource: \"User\" });\n *\n * // Runtime type check: instanceof TaggedError works!\n * console.log(error instanceof TaggedError); // true\n *\n * // Exhaustive matching\n * type AppError = NotFoundError | ValidationError;\n * const message = TaggedError.match(error as AppError, {\n *   NotFoundError: (e) => `Missing: ${e.resource} ${e.id}`,\n *   ValidationError: (e) => `Invalid ${e.field}: ${e.reason}`,\n * });\n * ```\n */\n\nimport { type AwaitlySlug, slugDocsUrl } from \"./slugs\";\n\n/**\n * Options for Error constructor (compatible with ES2022 ErrorOptions).\n */\nexport interface TaggedErrorOptions {\n  cause?: unknown;\n}\n\n/**\n * Options for TaggedError factory with type-safe message callback.\n */\nexport interface TaggedErrorCreateOptions<Props extends Record<string, unknown>> {\n  /** Custom message generator from props. Annotate parameter for type safety. */\n  message: (props: Props) => string;\n  /**\n   * Canonical awaitly slug for this error class. When set, instances carry\n   * `code`, `hint`, and `docsUrl` populated from the slugs namespace.\n   * Required together with `hint` for awaitly-system errors.\n   */\n  slug?: AwaitlySlug;\n  /**\n   * One-line \"do X instead\" guidance shown alongside the error.\n   * Required when `slug` is set.\n   */\n  hint?: string;\n}\n\n/**\n * Base interface for all tagged errors.\n */\nexport interface TaggedErrorBase extends Error {\n  readonly _tag: string;\n  /** Canonical slug for awaitly-system errors. Undefined for user errors that opt out. */\n  readonly code?: AwaitlySlug;\n  /** One-line guidance. Undefined when no slug is set. */\n  readonly hint?: string;\n  /** Canonical docs URL. Undefined when no slug is set. */\n  readonly docsUrl?: string;\n}\n\n/**\n * Internal base class for instanceof checks.\n * All TaggedError-created classes extend this.\n * @internal\n */\nclass InternalTaggedErrorBase extends Error implements TaggedErrorBase {\n  readonly _tag!: string;\n}\n\n/**\n * Instance type for factory-created TaggedErrors.\n */\ntype TaggedErrorInstance<Tag extends string, Props> = TaggedErrorBase & {\n  readonly _tag: Tag;\n} & Readonly<Props>;\n\n/**\n * Constructor args type - conditionally optional based on whether Props has required fields.\n * - If Props is empty or all properties are optional: props argument is optional\n * - If Props has any required properties: props argument is required\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\ntype ConstructorArgs<Props extends Record<string, unknown>> = {} extends Props\n  ? [props?: Props | void, options?: TaggedErrorOptions]\n  : [props: Props, options?: TaggedErrorOptions];\n\n/**\n * Constructor type returned by TaggedError factory.\n */\nexport interface TaggedErrorConstructor<\n  Tag extends string,\n  Props extends Record<string, unknown>,\n> {\n  new (...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;\n  readonly prototype: TaggedErrorInstance<Tag, Props>;\n}\n\n/**\n * Generic class factory type that allows `<Props>` parameterization.\n * This enables the Effect.js-style syntax: `class X extends TaggedError(\"X\")<Props> {}`\n * @internal\n */\nexport interface TaggedErrorClassFactory<Tag extends string> {\n  new <Props extends Record<string, unknown> = Record<string, never>>(\n    ...args: ConstructorArgs<Props>\n  ): TaggedErrorInstance<Tag, Props>;\n}\n\n/**\n * Helper type to extract return type from a function type.\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype FnReturnType<T> = T extends (...args: any[]) => infer R ? R : never;\n\n/**\n * Helper type to get union of return types from all handlers.\n * @internal\n */\ntype HandlersReturnType<H> = { [K in keyof H]: FnReturnType<H[K]> }[keyof H];\n\n/**\n * Helper type to extract keys whose values are definitely functions (not undefined).\n * Only excludes a tag from the fallback type if its handler is guaranteed to be\n * a function. Keys where the value type includes undefined are NOT excluded,\n * ensuring type safety with dynamic/conditional handlers.\n * @internal\n */\ntype DefinitelyHandledKeys<H> = {\n  [K in keyof H]-?: undefined extends H[K] ? never : K;\n}[keyof H];\n\n/**\n * Factory function to create tagged error classes.\n *\n * Two usage patterns:\n *\n * 1. **Props via generic** (default message is tag name):\n *    ```typescript\n *    class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n *    ```\n *\n * 2. **Props inferred from message callback** (type-safe message):\n *    ```typescript\n *    class NotFoundError extends TaggedError(\"NotFoundError\", {\n *      message: (p: { id: string }) => `Not found: ${p.id}`,\n *    }) {}\n *    ```\n *\n * Both support `instanceof TaggedError` checks at runtime.\n *\n * @param tag - The unique tag string for this error type\n * @param options - Optional configuration with message generator (annotate param for type safety)\n * @returns A class constructor that can be extended\n */\n\n// Overload 1: No options - use <Props> generic syntax, default message is tag\nfunction TaggedError<Tag extends string>(\n  tag: Tag\n): TaggedErrorClassFactory<Tag>;\n\n// Overload 2: With message option - Props inferred from callback parameter annotation\nfunction TaggedError<Tag extends string, Props extends Record<string, unknown>>(\n  tag: Tag,\n  options: TaggedErrorCreateOptions<Props>\n): TaggedErrorConstructor<Tag, Props>;\n\n// Implementation\nfunction TaggedError<Tag extends string, Props extends Record<string, unknown>>(\n  tag: Tag,\n  options?: TaggedErrorCreateOptions<Props>\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n): any {\n  return class extends InternalTaggedErrorBase {\n    override readonly _tag: Tag = tag;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    constructor(props?: any, errorOptions?: TaggedErrorOptions) {\n      // Generate message: call callback if provided (even for prop-less errors), else use tag\n      const message = options?.message ? options.message(props ?? {}) : tag;\n\n      super(message);\n      this.name = tag;\n\n      // Spine fields: populate when factory was given a slug\n      if (options?.slug !== undefined) {\n        if (!options.hint) {\n          throw new TypeError(\n            `TaggedError: 'hint' is required when 'slug' is set (slug: \"${options.slug}\")`\n          );\n        }\n        Object.defineProperty(this, \"code\", {\n          value: options.slug,\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n        Object.defineProperty(this, \"hint\", {\n          value: options.hint,\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n        Object.defineProperty(this, \"docsUrl\", {\n          value: slugDocsUrl(options.slug),\n          enumerable: true,\n          writable: false,\n          configurable: false,\n        });\n      }\n\n      // Maintains proper prototype chain for instanceof checks\n      Object.setPrototypeOf(this, new.target.prototype);\n\n      // Assign props to instance, stripping reserved keys:\n      // - _tag: discriminant for pattern matching (cannot be forged)\n      // - name, message, stack: Error internals (preserve for logging/debugging)\n      // - code, hint, docsUrl: spine fields stripped when slug is set, to prevent\n      //   Object.assign from clobbering the non-configurable/non-writable own props\n      // Note: 'cause' is allowed as a user prop (common for domain errors)\n      if (props && typeof props === \"object\") {\n        let safeProps: Record<string, unknown>;\n        if (options?.slug !== undefined) {\n          const {\n            _tag: _,\n            name: _n,\n            message: _m,\n            stack: _s,\n            code: _c,\n            hint: _h,\n            docsUrl: _d,\n            ...rest\n          } = props;\n          safeProps = rest;\n        } else {\n          const {\n            _tag: _,\n            name: _n,\n            message: _m,\n            stack: _s,\n            ...rest\n          } = props;\n          safeProps = rest;\n        }\n\n        const hasUserCause = Object.prototype.hasOwnProperty.call(\n          safeProps,\n          \"cause\"\n        );\n        const userCause = hasUserCause\n          ? (safeProps as { cause?: unknown }).cause\n          : undefined;\n        if (hasUserCause) {\n          delete (safeProps as { cause?: unknown }).cause;\n        }\n\n        const hasOptionsCause = errorOptions?.cause !== undefined;\n        if (hasUserCause && hasOptionsCause) {\n          throw new TypeError(\n            \"TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause\"\n          );\n        }\n\n        Object.assign(this, safeProps);\n\n        if (hasUserCause) {\n          (this as { cause?: unknown }).cause = userCause;\n        }\n        if (hasOptionsCause) {\n          (this as { cause?: unknown }).cause = errorOptions?.cause;\n        }\n      } else if (errorOptions?.cause !== undefined) {\n        (this as { cause?: unknown }).cause = errorOptions.cause;\n      }\n    }\n  };\n}\n\n// Add Symbol.hasInstance so `instanceof TaggedError` works\nObject.defineProperty(TaggedError, Symbol.hasInstance, {\n  value: (instance: unknown): boolean => instance instanceof InternalTaggedErrorBase,\n});\n\n/**\n * Namespace for static methods on TaggedError.\n */\n// eslint-disable-next-line @typescript-eslint/no-namespace\nnamespace TaggedError {\n  /**\n   * Type guard to check if a value is an Error instance.\n   */\n  export function isError(value: unknown): value is Error {\n    return value instanceof Error;\n  }\n\n  /**\n   * Type guard to check if a value is a TaggedError instance.\n   * Uses the same check as `instanceof TaggedError` - only genuine\n   * TaggedError instances (created via the factory) pass this guard.\n   */\n  export function isTaggedError(value: unknown): value is TaggedErrorBase {\n    return value instanceof InternalTaggedErrorBase;\n  }\n\n  /**\n   * Exhaustively matches on a tagged error, requiring handlers for all variants.\n   *\n   * TypeScript will error if any variant in the error union is not handled.\n   *\n   * @remarks When to use: You want compile-time enforcement that every tagged variant is handled.\n   *\n   * @param error - The tagged error to match\n   * @param handlers - Object mapping _tag values to handler functions\n   * @returns The return value of the matched handler\n   *\n   * @example\n   * ```typescript\n   * type AppError = NotFoundError | ValidationError;\n   *\n   * const message = TaggedError.match(error, {\n   *   NotFoundError: (e) => `Not found: ${e.id}`,\n   *   ValidationError: (e) => `Invalid: ${e.field}`,\n   * });\n   * ```\n   */\n  export function match<\n    E extends TaggedErrorBase,\n    H extends { [K in E[\"_tag\"]]: (e: Extract<E, { _tag: K }>) => unknown },\n  >(error: E, handlers: H): HandlersReturnType<H> {\n    const tag = error._tag as E[\"_tag\"];\n    const handler = handlers[tag];\n    return handler(\n      error as Extract<E, { _tag: typeof tag }>\n    ) as HandlersReturnType<H>;\n  }\n\n  /**\n   * Partially matches on a tagged error with a fallback for unhandled variants.\n   *\n   * The fallback receives variants that are NOT definitely handled. A tag is\n   * considered \"definitely handled\" only if its handler is a function (not\n   * `undefined`). This ensures type safety even with dynamic/conditional handlers:\n   *\n   * ```typescript\n   * const maybeHandle = featureFlag ? (e) => e.id : undefined;\n   * TaggedError.matchPartial(\n   *   error,\n   *   { NotFoundError: maybeHandle },  // maybeHandle might be undefined\n   *   (e) => e._tag  // e correctly includes NotFoundError\n   * );\n   * ```\n   *\n   * @param error - The tagged error to match\n   * @param handlers - Partial object mapping _tag values to handler functions\n   * @param otherwise - Fallback handler for unmatched variants\n   * @returns The return value of the matched handler or fallback\n   *\n   * @example\n   * ```typescript\n   * const message = TaggedError.matchPartial(\n   *   error,\n   *   { NotFoundError: (e) => `Not found: ${e.id}` },\n   *   (e) => `Other error: ${e.message}`\n   * );\n   * ```\n   */\n  export function matchPartial<\n    E extends TaggedErrorBase,\n    H extends Partial<{\n      [K in E[\"_tag\"]]: (e: Extract<E, { _tag: K }>) => unknown;\n    }>,\n    T,\n  >(\n    error: E,\n    handlers: H,\n    otherwise: (e: Exclude<E, { _tag: DefinitelyHandledKeys<H> }>) => T\n  ): HandlersReturnType<H> | T {\n    const tag = error._tag as E[\"_tag\"];\n    const handler = handlers[tag];\n    if (handler) {\n      return handler(\n        error as Extract<E, { _tag: typeof tag }>\n      ) as HandlersReturnType<H>;\n    }\n    return otherwise(error as Exclude<E, { _tag: DefinitelyHandledKeys<H> }>);\n  }\n}\n\nexport { TaggedError };\n\n/**\n * Helper type to extract the _tag literal type from a TaggedError.\n *\n * @example\n * ```typescript\n * class MyError extends TaggedError(\"MyError\")<{ id: string }> {}\n * type Tag = TagOf<MyError>; // \"MyError\"\n * ```\n */\nexport type TagOf<E extends TaggedErrorBase> = E[\"_tag\"];\n\n/**\n * Helper type to extract a specific variant from a TaggedError union by tag.\n *\n * @example\n * ```typescript\n * type AppError = NotFoundError | ValidationError;\n * type NotFound = ErrorByTag<AppError, \"NotFoundError\">; // NotFoundError\n * ```\n */\nexport type ErrorByTag<\n  E extends TaggedErrorBase,\n  Tag extends E[\"_tag\"],\n> = Extract<E, { _tag: Tag }>;\n\n/**\n * Reserved keys that are stripped from user props at runtime.\n * These keys cannot be used as user-defined properties:\n * - _tag: discriminant for pattern matching\n * - name, message, stack: Error internals (preserved for logging/debugging)\n * - code, hint, docsUrl: spine fields (non-configurable own properties when slug is set)\n *\n * Note: 'cause' is NOT reserved - it can be used as a user prop.\n */\ntype ReservedErrorKeys = \"_tag\" | \"name\" | \"message\" | \"stack\" | \"code\" | \"hint\" | \"docsUrl\";\n\n/**\n * Helper type to extract props from a TaggedError.\n * Excludes reserved keys that are stripped at runtime.\n *\n * @example\n * ```typescript\n * class MyError extends TaggedError(\"MyError\")<{ id: string }> {}\n * type Props = PropsOf<MyError>; // { id: string }\n *\n * // 'cause' is allowed as a user prop\n * class DomainError extends TaggedError(\"DomainError\")<{ cause: { field: string } }> {}\n * type DomainProps = PropsOf<DomainError>; // { cause: { field: string } }\n * ```\n */\nexport type PropsOf<E extends TaggedErrorBase> = Omit<E, ReservedErrorKeys>;\n"],"mappings":"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","names":["tagged_error_entry_exports","__export","TaggedError","__toCommonJS","AWAITLY_SLUGS","slugDocsUrl","slug","ALL_SLUGS","AWAITLY_SLUGS","InternalTaggedErrorBase","TaggedError","tag","options","props","errorOptions","message","slugDocsUrl","safeProps","_","_n","_m","_s","_c","_h","_d","rest","hasUserCause","userCause","hasOptionsCause","instance","isError","value","isTaggedError","match","error","handlers","handler","matchPartial","otherwise"]}

package/dist/tagged-error.d.cts

@@ -1,275 +0,0 @@
-import { AwaitlySlug } from './slugs.cjs';
-
-/**
- * awaitly/tagged-error
- *
- * Factory for creating tagged error types with exhaustive pattern matching.
- * Enables TypeScript to enforce that all error variants are handled.
- *
- * @example
- * ```typescript
- * // Define error types (Props via generic)
- * class NotFoundError extends TaggedError("NotFoundError")<{
- *   id: string;
- *   resource: string;
- * }> {}
- *
- * // Define with type-safe message (Props inferred from callback annotation)
- * class ValidationError extends TaggedError("ValidationError", {
- *   message: (p: { field: string; reason: string }) => `Invalid ${p.field}: ${p.reason}`,
- * }) {}
- *
- * // Create instances
- * const error = new NotFoundError({ id: "123", resource: "User" });
- *
- * // Runtime type check: instanceof TaggedError works!
- * console.log(error instanceof TaggedError); // true
- *
- * // Exhaustive matching
- * type AppError = NotFoundError | ValidationError;
- * const message = TaggedError.match(error as AppError, {
- *   NotFoundError: (e) => `Missing: ${e.resource} ${e.id}`,
- *   ValidationError: (e) => `Invalid ${e.field}: ${e.reason}`,
- * });
- * ```
- */
-
-/**
- * Options for Error constructor (compatible with ES2022 ErrorOptions).
- */
-interface TaggedErrorOptions {
-    cause?: unknown;
-}
-/**
- * Options for TaggedError factory with type-safe message callback.
- */
-interface TaggedErrorCreateOptions<Props extends Record<string, unknown>> {
-    /** Custom message generator from props. Annotate parameter for type safety. */
-    message: (props: Props) => string;
-    /**
-     * Canonical awaitly slug for this error class. When set, instances carry
-     * `code`, `hint`, and `docsUrl` populated from the slugs namespace.
-     * Required together with `hint` for awaitly-system errors.
-     */
-    slug?: AwaitlySlug;
-    /**
-     * One-line "do X instead" guidance shown alongside the error.
-     * Required when `slug` is set.
-     */
-    hint?: string;
-}
-/**
- * Base interface for all tagged errors.
- */
-interface TaggedErrorBase extends Error {
-    readonly _tag: string;
-    /** Canonical slug for awaitly-system errors. Undefined for user errors that opt out. */
-    readonly code?: AwaitlySlug;
-    /** One-line guidance. Undefined when no slug is set. */
-    readonly hint?: string;
-    /** Canonical docs URL. Undefined when no slug is set. */
-    readonly docsUrl?: string;
-}
-/**
- * Instance type for factory-created TaggedErrors.
- */
-type TaggedErrorInstance<Tag extends string, Props> = TaggedErrorBase & {
-    readonly _tag: Tag;
-} & Readonly<Props>;
-/**
- * Constructor args type - conditionally optional based on whether Props has required fields.
- * - If Props is empty or all properties are optional: props argument is optional
- * - If Props has any required properties: props argument is required
- * @internal
- */
-type ConstructorArgs<Props extends Record<string, unknown>> = {} extends Props ? [props?: Props | void, options?: TaggedErrorOptions] : [props: Props, options?: TaggedErrorOptions];
-/**
- * Constructor type returned by TaggedError factory.
- */
-interface TaggedErrorConstructor<Tag extends string, Props extends Record<string, unknown>> {
-    new (...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
-    readonly prototype: TaggedErrorInstance<Tag, Props>;
-}
-/**
- * Generic class factory type that allows `<Props>` parameterization.
- * This enables the Effect.js-style syntax: `class X extends TaggedError("X")<Props> {}`
- * @internal
- */
-interface TaggedErrorClassFactory<Tag extends string> {
-    new <Props extends Record<string, unknown> = Record<string, never>>(...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
-}
-/**
- * Helper type to extract return type from a function type.
- * @internal
- */
-type FnReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-/**
- * Helper type to get union of return types from all handlers.
- * @internal
- */
-type HandlersReturnType<H> = {
-    [K in keyof H]: FnReturnType<H[K]>;
-}[keyof H];
-/**
- * Helper type to extract keys whose values are definitely functions (not undefined).
- * Only excludes a tag from the fallback type if its handler is guaranteed to be
- * a function. Keys where the value type includes undefined are NOT excluded,
- * ensuring type safety with dynamic/conditional handlers.
- * @internal
- */
-type DefinitelyHandledKeys<H> = {
-    [K in keyof H]-?: undefined extends H[K] ? never : K;
-}[keyof H];
-/**
- * Factory function to create tagged error classes.
- *
- * Two usage patterns:
- *
- * 1. **Props via generic** (default message is tag name):
- *    ```typescript
- *    class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
- *    ```
- *
- * 2. **Props inferred from message callback** (type-safe message):
- *    ```typescript
- *    class NotFoundError extends TaggedError("NotFoundError", {
- *      message: (p: { id: string }) => `Not found: ${p.id}`,
- *    }) {}
- *    ```
- *
- * Both support `instanceof TaggedError` checks at runtime.
- *
- * @param tag - The unique tag string for this error type
- * @param options - Optional configuration with message generator (annotate param for type safety)
- * @returns A class constructor that can be extended
- */
-declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorClassFactory<Tag>;
-declare function TaggedError<Tag extends string, Props extends Record<string, unknown>>(tag: Tag, options: TaggedErrorCreateOptions<Props>): TaggedErrorConstructor<Tag, Props>;
-/**
- * Namespace for static methods on TaggedError.
- */
-declare namespace TaggedError {
-    /**
-     * Type guard to check if a value is an Error instance.
-     */
-    function isError(value: unknown): value is Error;
-    /**
-     * Type guard to check if a value is a TaggedError instance.
-     * Uses the same check as `instanceof TaggedError` - only genuine
-     * TaggedError instances (created via the factory) pass this guard.
-     */
-    function isTaggedError(value: unknown): value is TaggedErrorBase;
-    /**
-     * Exhaustively matches on a tagged error, requiring handlers for all variants.
-     *
-     * TypeScript will error if any variant in the error union is not handled.
-     *
-     * @remarks When to use: You want compile-time enforcement that every tagged variant is handled.
-     *
-     * @param error - The tagged error to match
-     * @param handlers - Object mapping _tag values to handler functions
-     * @returns The return value of the matched handler
-     *
-     * @example
-     * ```typescript
-     * type AppError = NotFoundError | ValidationError;
-     *
-     * const message = TaggedError.match(error, {
-     *   NotFoundError: (e) => `Not found: ${e.id}`,
-     *   ValidationError: (e) => `Invalid: ${e.field}`,
-     * });
-     * ```
-     */
-    function match<E extends TaggedErrorBase, H extends {
-        [K in E["_tag"]]: (e: Extract<E, {
-            _tag: K;
-        }>) => unknown;
-    }>(error: E, handlers: H): HandlersReturnType<H>;
-    /**
-     * Partially matches on a tagged error with a fallback for unhandled variants.
-     *
-     * The fallback receives variants that are NOT definitely handled. A tag is
-     * considered "definitely handled" only if its handler is a function (not
-     * `undefined`). This ensures type safety even with dynamic/conditional handlers:
-     *
-     * ```typescript
-     * const maybeHandle = featureFlag ? (e) => e.id : undefined;
-     * TaggedError.matchPartial(
-     *   error,
-     *   { NotFoundError: maybeHandle },  // maybeHandle might be undefined
-     *   (e) => e._tag  // e correctly includes NotFoundError
-     * );
-     * ```
-     *
-     * @param error - The tagged error to match
-     * @param handlers - Partial object mapping _tag values to handler functions
-     * @param otherwise - Fallback handler for unmatched variants
-     * @returns The return value of the matched handler or fallback
-     *
-     * @example
-     * ```typescript
-     * const message = TaggedError.matchPartial(
-     *   error,
-     *   { NotFoundError: (e) => `Not found: ${e.id}` },
-     *   (e) => `Other error: ${e.message}`
-     * );
-     * ```
-     */
-    function matchPartial<E extends TaggedErrorBase, H extends Partial<{
-        [K in E["_tag"]]: (e: Extract<E, {
-            _tag: K;
-        }>) => unknown;
-    }>, T>(error: E, handlers: H, otherwise: (e: Exclude<E, {
-        _tag: DefinitelyHandledKeys<H>;
-    }>) => T): HandlersReturnType<H> | T;
-}
-
-/**
- * Helper type to extract the _tag literal type from a TaggedError.
- *
- * @example
- * ```typescript
- * class MyError extends TaggedError("MyError")<{ id: string }> {}
- * type Tag = TagOf<MyError>; // "MyError"
- * ```
- */
-type TagOf<E extends TaggedErrorBase> = E["_tag"];
-/**
- * Helper type to extract a specific variant from a TaggedError union by tag.
- *
- * @example
- * ```typescript
- * type AppError = NotFoundError | ValidationError;
- * type NotFound = ErrorByTag<AppError, "NotFoundError">; // NotFoundError
- * ```
- */
-type ErrorByTag<E extends TaggedErrorBase, Tag extends E["_tag"]> = Extract<E, {
-    _tag: Tag;
-}>;
-/**
- * Reserved keys that are stripped from user props at runtime.
- * These keys cannot be used as user-defined properties:
- * - _tag: discriminant for pattern matching
- * - name, message, stack: Error internals (preserved for logging/debugging)
- * - code, hint, docsUrl: spine fields (non-configurable own properties when slug is set)
- *
- * Note: 'cause' is NOT reserved - it can be used as a user prop.
- */
-type ReservedErrorKeys = "_tag" | "name" | "message" | "stack" | "code" | "hint" | "docsUrl";
-/**
- * Helper type to extract props from a TaggedError.
- * Excludes reserved keys that are stripped at runtime.
- *
- * @example
- * ```typescript
- * class MyError extends TaggedError("MyError")<{ id: string }> {}
- * type Props = PropsOf<MyError>; // { id: string }
- *
- * // 'cause' is allowed as a user prop
- * class DomainError extends TaggedError("DomainError")<{ cause: { field: string } }> {}
- * type DomainProps = PropsOf<DomainError>; // { cause: { field: string } }
- * ```
- */
-type PropsOf<E extends TaggedErrorBase> = Omit<E, ReservedErrorKeys>;
-
-export { type ErrorByTag, type PropsOf, type TagOf, TaggedError, type TaggedErrorBase, type TaggedErrorConstructor, type TaggedErrorCreateOptions, type TaggedErrorOptions };

package/dist/tagged-error.d.ts

@@ -1,275 +0,0 @@
-import { AwaitlySlug } from './slugs.js';
-
-/**
- * awaitly/tagged-error
- *
- * Factory for creating tagged error types with exhaustive pattern matching.
- * Enables TypeScript to enforce that all error variants are handled.
- *
- * @example
- * ```typescript
- * // Define error types (Props via generic)
- * class NotFoundError extends TaggedError("NotFoundError")<{
- *   id: string;
- *   resource: string;
- * }> {}
- *
- * // Define with type-safe message (Props inferred from callback annotation)
- * class ValidationError extends TaggedError("ValidationError", {
- *   message: (p: { field: string; reason: string }) => `Invalid ${p.field}: ${p.reason}`,
- * }) {}
- *
- * // Create instances
- * const error = new NotFoundError({ id: "123", resource: "User" });
- *
- * // Runtime type check: instanceof TaggedError works!
- * console.log(error instanceof TaggedError); // true
- *
- * // Exhaustive matching
- * type AppError = NotFoundError | ValidationError;
- * const message = TaggedError.match(error as AppError, {
- *   NotFoundError: (e) => `Missing: ${e.resource} ${e.id}`,
- *   ValidationError: (e) => `Invalid ${e.field}: ${e.reason}`,
- * });
- * ```
- */
-
-/**
- * Options for Error constructor (compatible with ES2022 ErrorOptions).
- */
-interface TaggedErrorOptions {
-    cause?: unknown;
-}
-/**
- * Options for TaggedError factory with type-safe message callback.
- */
-interface TaggedErrorCreateOptions<Props extends Record<string, unknown>> {
-    /** Custom message generator from props. Annotate parameter for type safety. */
-    message: (props: Props) => string;
-    /**
-     * Canonical awaitly slug for this error class. When set, instances carry
-     * `code`, `hint`, and `docsUrl` populated from the slugs namespace.
-     * Required together with `hint` for awaitly-system errors.
-     */
-    slug?: AwaitlySlug;
-    /**
-     * One-line "do X instead" guidance shown alongside the error.
-     * Required when `slug` is set.
-     */
-    hint?: string;
-}
-/**
- * Base interface for all tagged errors.
- */
-interface TaggedErrorBase extends Error {
-    readonly _tag: string;
-    /** Canonical slug for awaitly-system errors. Undefined for user errors that opt out. */
-    readonly code?: AwaitlySlug;
-    /** One-line guidance. Undefined when no slug is set. */
-    readonly hint?: string;
-    /** Canonical docs URL. Undefined when no slug is set. */
-    readonly docsUrl?: string;
-}
-/**
- * Instance type for factory-created TaggedErrors.
- */
-type TaggedErrorInstance<Tag extends string, Props> = TaggedErrorBase & {
-    readonly _tag: Tag;
-} & Readonly<Props>;
-/**
- * Constructor args type - conditionally optional based on whether Props has required fields.
- * - If Props is empty or all properties are optional: props argument is optional
- * - If Props has any required properties: props argument is required
- * @internal
- */
-type ConstructorArgs<Props extends Record<string, unknown>> = {} extends Props ? [props?: Props | void, options?: TaggedErrorOptions] : [props: Props, options?: TaggedErrorOptions];
-/**
- * Constructor type returned by TaggedError factory.
- */
-interface TaggedErrorConstructor<Tag extends string, Props extends Record<string, unknown>> {
-    new (...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
-    readonly prototype: TaggedErrorInstance<Tag, Props>;
-}
-/**
- * Generic class factory type that allows `<Props>` parameterization.
- * This enables the Effect.js-style syntax: `class X extends TaggedError("X")<Props> {}`
- * @internal
- */
-interface TaggedErrorClassFactory<Tag extends string> {
-    new <Props extends Record<string, unknown> = Record<string, never>>(...args: ConstructorArgs<Props>): TaggedErrorInstance<Tag, Props>;
-}
-/**
- * Helper type to extract return type from a function type.
- * @internal
- */
-type FnReturnType<T> = T extends (...args: any[]) => infer R ? R : never;
-/**
- * Helper type to get union of return types from all handlers.
- * @internal
- */
-type HandlersReturnType<H> = {
-    [K in keyof H]: FnReturnType<H[K]>;
-}[keyof H];
-/**
- * Helper type to extract keys whose values are definitely functions (not undefined).
- * Only excludes a tag from the fallback type if its handler is guaranteed to be
- * a function. Keys where the value type includes undefined are NOT excluded,
- * ensuring type safety with dynamic/conditional handlers.
- * @internal
- */
-type DefinitelyHandledKeys<H> = {
-    [K in keyof H]-?: undefined extends H[K] ? never : K;
-}[keyof H];
-/**
- * Factory function to create tagged error classes.
- *
- * Two usage patterns:
- *
- * 1. **Props via generic** (default message is tag name):
- *    ```typescript
- *    class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
- *    ```
- *
- * 2. **Props inferred from message callback** (type-safe message):
- *    ```typescript
- *    class NotFoundError extends TaggedError("NotFoundError", {
- *      message: (p: { id: string }) => `Not found: ${p.id}`,
- *    }) {}
- *    ```
- *
- * Both support `instanceof TaggedError` checks at runtime.
- *
- * @param tag - The unique tag string for this error type
- * @param options - Optional configuration with message generator (annotate param for type safety)
- * @returns A class constructor that can be extended
- */
-declare function TaggedError<Tag extends string>(tag: Tag): TaggedErrorClassFactory<Tag>;
-declare function TaggedError<Tag extends string, Props extends Record<string, unknown>>(tag: Tag, options: TaggedErrorCreateOptions<Props>): TaggedErrorConstructor<Tag, Props>;
-/**
- * Namespace for static methods on TaggedError.
- */
-declare namespace TaggedError {
-    /**
-     * Type guard to check if a value is an Error instance.
-     */
-    function isError(value: unknown): value is Error;
-    /**
-     * Type guard to check if a value is a TaggedError instance.
-     * Uses the same check as `instanceof TaggedError` - only genuine
-     * TaggedError instances (created via the factory) pass this guard.
-     */
-    function isTaggedError(value: unknown): value is TaggedErrorBase;
-    /**
-     * Exhaustively matches on a tagged error, requiring handlers for all variants.
-     *
-     * TypeScript will error if any variant in the error union is not handled.
-     *
-     * @remarks When to use: You want compile-time enforcement that every tagged variant is handled.
-     *
-     * @param error - The tagged error to match
-     * @param handlers - Object mapping _tag values to handler functions
-     * @returns The return value of the matched handler
-     *
-     * @example
-     * ```typescript
-     * type AppError = NotFoundError | ValidationError;
-     *
-     * const message = TaggedError.match(error, {
-     *   NotFoundError: (e) => `Not found: ${e.id}`,
-     *   ValidationError: (e) => `Invalid: ${e.field}`,
-     * });
-     * ```
-     */
-    function match<E extends TaggedErrorBase, H extends {
-        [K in E["_tag"]]: (e: Extract<E, {
-            _tag: K;
-        }>) => unknown;
-    }>(error: E, handlers: H): HandlersReturnType<H>;
-    /**
-     * Partially matches on a tagged error with a fallback for unhandled variants.
-     *
-     * The fallback receives variants that are NOT definitely handled. A tag is
-     * considered "definitely handled" only if its handler is a function (not
-     * `undefined`). This ensures type safety even with dynamic/conditional handlers:
-     *
-     * ```typescript
-     * const maybeHandle = featureFlag ? (e) => e.id : undefined;
-     * TaggedError.matchPartial(
-     *   error,
-     *   { NotFoundError: maybeHandle },  // maybeHandle might be undefined
-     *   (e) => e._tag  // e correctly includes NotFoundError
-     * );
-     * ```
-     *
-     * @param error - The tagged error to match
-     * @param handlers - Partial object mapping _tag values to handler functions
-     * @param otherwise - Fallback handler for unmatched variants
-     * @returns The return value of the matched handler or fallback
-     *
-     * @example
-     * ```typescript
-     * const message = TaggedError.matchPartial(
-     *   error,
-     *   { NotFoundError: (e) => `Not found: ${e.id}` },
-     *   (e) => `Other error: ${e.message}`
-     * );
-     * ```
-     */
-    function matchPartial<E extends TaggedErrorBase, H extends Partial<{
-        [K in E["_tag"]]: (e: Extract<E, {
-            _tag: K;
-        }>) => unknown;
-    }>, T>(error: E, handlers: H, otherwise: (e: Exclude<E, {
-        _tag: DefinitelyHandledKeys<H>;
-    }>) => T): HandlersReturnType<H> | T;
-}
-
-/**
- * Helper type to extract the _tag literal type from a TaggedError.
- *
- * @example
- * ```typescript
- * class MyError extends TaggedError("MyError")<{ id: string }> {}
- * type Tag = TagOf<MyError>; // "MyError"
- * ```
- */
-type TagOf<E extends TaggedErrorBase> = E["_tag"];
-/**
- * Helper type to extract a specific variant from a TaggedError union by tag.
- *
- * @example
- * ```typescript
- * type AppError = NotFoundError | ValidationError;
- * type NotFound = ErrorByTag<AppError, "NotFoundError">; // NotFoundError
- * ```
- */
-type ErrorByTag<E extends TaggedErrorBase, Tag extends E["_tag"]> = Extract<E, {
-    _tag: Tag;
-}>;
-/**
- * Reserved keys that are stripped from user props at runtime.
- * These keys cannot be used as user-defined properties:
- * - _tag: discriminant for pattern matching
- * - name, message, stack: Error internals (preserved for logging/debugging)
- * - code, hint, docsUrl: spine fields (non-configurable own properties when slug is set)
- *
- * Note: 'cause' is NOT reserved - it can be used as a user prop.
- */
-type ReservedErrorKeys = "_tag" | "name" | "message" | "stack" | "code" | "hint" | "docsUrl";
-/**
- * Helper type to extract props from a TaggedError.
- * Excludes reserved keys that are stripped at runtime.
- *
- * @example
- * ```typescript
- * class MyError extends TaggedError("MyError")<{ id: string }> {}
- * type Props = PropsOf<MyError>; // { id: string }
- *
- * // 'cause' is allowed as a user prop
- * class DomainError extends TaggedError("DomainError")<{ cause: { field: string } }> {}
- * type DomainProps = PropsOf<DomainError>; // { cause: { field: string } }
- * ```
- */
-type PropsOf<E extends TaggedErrorBase> = Omit<E, ReservedErrorKeys>;
-
-export { type ErrorByTag, type PropsOf, type TagOf, TaggedError, type TaggedErrorBase, type TaggedErrorConstructor, type TaggedErrorCreateOptions, type TaggedErrorOptions };

package/dist/tagged-error.js

@@ -1,2 +0,0 @@
-var T={"step-require-id":"step-require-id","step-no-immediate-execution":"step-no-immediate-execution","step-require-thunk-for-key":"step-require-thunk-for-key","step-no-bare-await":"step-no-bare-await","step-no-try-catch-wrap":"step-no-try-catch-wrap","step-stable-cache-keys":"step-stable-cache-keys","workflow-no-floating":"workflow-no-floating","workflow-options-position":"workflow-options-position","workflow-callback-shape":"workflow-callback-shape","workflow-no-callable-form":"workflow-no-callable-form","workflow-no-dynamic-import":"workflow-no-dynamic-import","result-no-floating":"result-no-floating","result-require-handling":"result-require-handling","result-no-double-wrap":"result-no-double-wrap","result-no-manual-propagation":"result-no-manual-propagation","result-no-direct-ok-err":"result-no-direct-ok-err","error-check-unexpected-first":"error-check-unexpected-first","error-access-cause":"error-access-cause","error-normalize":"error-normalize","error-no-throw-in-deps":"error-no-throw-in-deps","concurrency-no-promise-all":"concurrency-no-promise-all","concurrency-no-promise-race":"concurrency-no-promise-race","concurrency-no-promise-allsettled":"concurrency-no-promise-allsettled","runtime-step-timeout":"runtime-step-timeout","runtime-step-aborted":"runtime-step-aborted","runtime-retry-exhausted":"runtime-retry-exhausted","runtime-rate-limit":"runtime-rate-limit","runtime-circuit-open":"runtime-circuit-open","runtime-unexpected":"runtime-unexpected","runtime-resolver-not-found":"runtime-resolver-not-found","runtime-saga-compensation":"runtime-saga-compensation"};function p(t){return`https://jagreehal.github.io/awaitly/rules/#${t}`}var h=Object.keys(T);var g=class extends Error{_tag};function c(t,r){return class extends g{_tag=t;constructor(o,s){let l=r?.message?r.message(o??{}):t;if(super(l),this.name=t,r?.slug!==void 0){if(!r.hint)throw new TypeError(`TaggedError: 'hint' is required when 'slug' is set (slug: "${r.slug}")`);Object.defineProperty(this,"code",{value:r.slug,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"hint",{value:r.hint,enumerable:!0,writable:!1,configurable:!1}),Object.defineProperty(this,"docsUrl",{value:p(r.slug),enumerable:!0,writable:!1,configurable:!1})}if(Object.setPrototypeOf(this,new.target.prototype),o&&typeof o=="object"){let e;if(r?.slug!==void 0){let{_tag:u,name:y,message:f,stack:w,code:d,hint:m,docsUrl:x,...E}=o;e=E}else{let{_tag:u,name:y,message:f,stack:w,...d}=o;e=d}let n=Object.prototype.hasOwnProperty.call(e,"cause"),i=n?e.cause:void 0;n&&delete e.cause;let a=s?.cause!==void 0;if(n&&a)throw new TypeError("TaggedError: cannot provide 'cause' in props when also setting ErrorOptions.cause");Object.assign(this,e),n&&(this.cause=i),a&&(this.cause=s?.cause)}else s?.cause!==void 0&&(this.cause=s.cause)}}}Object.defineProperty(c,Symbol.hasInstance,{value:t=>t instanceof g});(l=>{function t(e){return e instanceof Error}l.isError=t;function r(e){return e instanceof g}l.isTaggedError=r;function o(e,n){let i=e._tag,a=n[i];return a(e)}l.match=o;function s(e,n,i){let a=e._tag,u=n[a];return u?u(e):i(e)}l.matchPartial=s})(c||={});export{c as TaggedError};
-//# sourceMappingURL=tagged-error.js.map