@resultsafe/core-fp-result 0.1.10 → 0.2.1

package/types/refiners/types/VariantOf.d.ts

@@ -1,4 +1,23 @@
-/** Описывает минимальный контракт дискриминированного объединения. */
+/**
+ * Describes the minimal contract for a discriminated union variant.
+ *
+ * @typeParam K - The variant key type. Defaults to `string`.
+ *
+ * @remarks
+ * This type is used as a constraint for variant unions. Each variant
+ * must have a `type` field that serves as the discriminator.
+ *
+ * @example
+ * ```ts
+ * import { VariantOf } from '@resultsafe/core-fp-result';
+ *
+ * type MyVariant = VariantOf<'user' | 'error'>;
+ * // { type: 'user' } | { type: 'error' }
+ * ```
+ *
+ * @since 0.1.8
+ * @public
+ */
 export type VariantOf<K extends string = string> = {
     type: K;
 };

package/types/refiners/types/VariantOf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VariantOf.d.ts","sourceRoot":"","sources":["../../../../src/refiners/types/VariantOf.ts"],"names":[],"mappings":"AAAA,sEAAsE;AACtE,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC"}
+{"version":3,"file":"VariantOf.d.ts","sourceRoot":"","sources":["../../../../src/refiners/types/VariantOf.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,CAAC"}

package/types/refiners/utils/getPayloadKeys.d.ts

@@ -1,10 +1,11 @@
-import type { PayloadKeys, VariantConfig } from '../../shared-types.js';
+import type { PayloadKeys } from '../../types/refiners/PayloadKeys.js';
+import type { VariantConfig } from '../../types/refiners/VariantConfig.js';
 /**
- * Нормализует конфигурацию payload варианта в список ключей.
+ * Normalizes a variant payload configuration into a list of keys.
  *
- * @typeParam C - Тип конфигурации варианта.
- * @param config - Конфигурация варианта с определением payload.
- * @returns Ключи payload как readonly-массив.
+ * @typeParam C - The variant configuration type.
+ * @param config - The variant configuration with payload definition.
+ * @returns The payload keys as a readonly array.
  * @since 0.1.0
  * @example
  * ```ts

package/types/refiners/utils/getPayloadKeys.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPayloadKeys.d.ts","sourceRoot":"","sources":["../../../../src/refiners/utils/getPayloadKeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,aAAa,EACpD,QAAQ,CAAC,KACR,SAAS,WAAW,CAAC,CAAC,CAAC,EAIzB,CAAC"}
+{"version":3,"file":"getPayloadKeys.d.ts","sourceRoot":"","sources":["../../../../src/refiners/utils/getPayloadKeys.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qCAAqC,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAC;AAE3E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,aAAa,EACpD,QAAQ,CAAC,KACR,SAAS,WAAW,CAAC,CAAC,CAAC,EAIzB,CAAC"}

package/types/types/core/index.d.ts

@@ -0,0 +1,3 @@
+export type { Option } from './Option.js';
+export type { Result } from './Result.js';
+//# sourceMappingURL=index.d.ts.map

package/types/types/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/types/core/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/types/types/index.d.ts

@@ -1,5 +1,4 @@
-export type { Option } from './core/Option.js';
-export type { Result } from './core/Result.js';
+export type { Option, Result } from './core/index.js';
 export type { AsyncValidatorFn } from './refiners/AsyncValidatorFn.js';
 export type { PayloadKeys } from './refiners/PayloadKeys.js';
 export type { ValidatorFn } from './refiners/ValidatorFn.js';

package/types/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,YAAY,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG/C,YAAY,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAGtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAC7D,YAAY,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC"}

package/umd/resultsafe-monorepo-core-fp-result.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"resultsafe-monorepo-core-fp-result.umd.js","sources":["../../src/constructors/Err.ts","../../src/constructors/Ok.ts","../../src/guards/isErr.ts","../../src/guards/isErrAnd.ts","../../src/guards/isOk.ts","../../src/guards/isOkAnd.ts","../../src/methods/andThen.ts","../../src/internal/option.ts","../../src/methods/err.ts","../../src/methods/expect.ts","../../src/methods/expectErr.ts","../../src/methods/flatten.ts","../../src/methods/inspect.ts","../../src/methods/inspectErr.ts","../../src/methods/map.ts","../../src/methods/mapErr.ts","../../src/methods/match.ts","../../src/methods/ok.ts","../../src/methods/orElse.ts","../../src/methods/tap.ts","../../src/methods/tapErr.ts","../../src/methods/transpose.ts","../../src/methods/unwrap.ts","../../src/methods/unwrapErr.ts","../../src/methods/unwrapOr.ts","../../src/methods/unwrapOrElse.ts","../../src/refiners/isTypedVariant.ts","../../src/refiners/isTypedVariantOf.ts","../../src/refiners/matchVariant.ts","../../src/refiners/matchVariantStrict.ts","../../src/internal/object.ts","../../src/refiners/refineAsyncResult.ts","../../src/refiners/refineAsyncResultU.ts","../../src/refiners/utils/getPayloadKeys.ts","../../src/refiners/refineResult.ts","../../src/refiners/refineResultU.ts","../../src/refiners/refineVariantMap.ts"],"sourcesContent":["import type { Result } from '../shared-types.js';\n\n/**\n * Создает ошибочное значение `Result` из переданного payload ошибки.\n *\n * @typeParam E - Тип значения ошибки.\n * @typeParam T - The success type for the resulting `Result`.\n * @param error - Payload ошибки для обёртки.\n * @returns A `Result` with `ok: false` and the provided `error`.\n * @since 0.1.0\n * @see {@link Ok} - Creates a successful `Result`.\n * @example\n * ```ts\n * import { Err } from '@resultsafe/core-fp-result';\n *\n * const result = Err<string, number>('boom');\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const Err = <E, T = never>(error: E): Result<T, E> =>\n  ({ ok: false, error }) as const;\n","import type { Result } from '../shared-types.js';\n\n/**\n * Создает успешное значение `Result` из переданного payload.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - The error type for the resulting `Result`.\n * @param value - Payload успеха для обёртки.\n * @returns A `Result` with `ok: true` and the provided `value`.\n * @since 0.1.0\n * @see {@link Err} - Creates an error `Result`.\n * @example\n * ```ts\n * import { Ok } from '@resultsafe/core-fp-result';\n *\n * const result = Ok<number, string>(42);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const Ok = <T, E = never>(value: T): Result<T, E> =>\n  ({ ok: true, value }) as const;\n","import type { Result } from '../shared-types.js';\n\n/**\n * Проверяет, находится ли `Result` в ветке ошибки.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @returns `true` when `result.ok` equals `false`.\n * @since 0.1.0\n * @see {@link isOk} - Checks the success branch.\n * @example\n * ```ts\n * import { Err, isErr } from '@resultsafe/core-fp-result';\n *\n * const result = Err('boom');\n * console.log(isErr(result)); // true\n * ```\n * @public\n */\nexport const isErr = <T, E>(\n  result: Result<T, E>,\n): result is { ok: false; error: E } => result.ok === false;\n","import { type Result } from '../shared-types.js';\nimport { isErr } from './isErr.js';\n\n/**\n * Проверяет, что `Result` завершился ошибкой и удовлетворяет предикату.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @param predicate - Предикат, применяемый к значению ошибки.\n * @returns `true` when the value is `Err` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isErr} - Performs the base error check.\n * @example\n * ```ts\n * import { Err, isErrAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Err({ code: 503 });\n * console.log(isErrAnd(result, (error) => error.code >= 500)); // true\n * ```\n * @public\n */\nexport const isErrAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (error: E) => boolean,\n): boolean => isErr(result) && predicate(result.error);\n","import type { Result } from '../shared-types.js';\n\n/**\n * Проверяет, находится ли `Result` в ветке успеха.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @returns `true` when `result.ok` equals `true`.\n * @since 0.1.0\n * @see {@link isErr} - Checks the error branch.\n * @example\n * ```ts\n * import { Ok, isOk } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(10);\n * console.log(isOk(result)); // true\n * ```\n * @public\n */\nexport const isOk = <T, E>(\n  result: Result<T, E>,\n): result is { ok: true; value: T } => result.ok === true;\n","import { type Result } from '../shared-types.js';\nimport { isOk } from './isOk.js';\n\n/**\n * Проверяет, что `Result` успешен и удовлетворяет предикату.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - `Result` для проверки.\n * @param predicate - Предикат, применяемый к успешному значению.\n * @returns `true` when the value is `Ok` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isOk} - Performs the base success check.\n * @example\n * ```ts\n * import { Ok, isOkAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(8);\n * console.log(isOkAnd(result, (value) => value % 2 === 0)); // true\n * ```\n * @public\n */\nexport const isOkAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (value: T) => boolean,\n): boolean => isOk(result) && predicate(result.value);\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Цепляет вычисление, которое возвращает другой `Result`.\n *\n * @typeParam T - The input success type.\n * @typeParam U - The output success type.\n * @typeParam E - Общий тип ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция, применяемая, когда `result` имеет `Ok`.\n * @returns Преобразованный `Result` или исходный `Err`.\n * @since 0.1.0\n * @see {@link map} - Преобразует только успешное значение.\n * @example\n * ```ts\n * import { Ok, Err, andThen } from '@resultsafe/core-fp-result';\n *\n * const parsed = andThen(Ok('12'), (value) => {\n *   const n = Number(value);\n *   return Number.isNaN(n) ? Err('invalid') : Ok(n);\n * });\n * console.log(parsed.ok); // true\n * ```\n * @public\n */\nexport const andThen = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, E>,\n): Result<U, E> => (isOk(result) ? fn(result.value) : (result as Result<U, E>));\n","/** Represents an empty internal option value. @internal */\nexport const None = { some: false } as const;\n\n/** Wraps an internal option value as present. @internal */\nexport const Some = <T>(value: T) => ({ some: true, value }) as const;\n","import { isErr } from '../guards/isErr.js';\nimport { None, Some } from '../internal/option.js';\nimport { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Извлекает ветку ошибки в виде `Option`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns `Some(error)` для `Err`, иначе `None`.\n * @since 0.1.0\n * @see {@link ok} - Извлекает ветку успеха.\n * @example\n * ```ts\n * import { Err, err } from '@resultsafe/core-fp-result';\n *\n * const value = err(Err('boom'));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const err = <T, E>(result: Result<T, E>): Option<E> =>\n  isErr(result) ? Some(result.error) : None;\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Возвращает успешное значение или выбрасывает исключение с пользовательским сообщением.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Err`.\n * @returns Распакованное успешное значение.\n * @throws Error - Выбрасывает исключение, когда `result` имеет `Err`.\n * @since 0.1.0\n * @see {@link expectErr} - Симметричный helper для ветки ошибки.\n * @example\n * ```ts\n * import { Ok, expect } from '@resultsafe/core-fp-result';\n *\n * const value = expect(Ok(5), 'must be ok');\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const expect = <T, E>(result: Result<T, E>, msg: string): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error(msg);\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Возвращает значение ошибки или выбрасывает исключение с пользовательским сообщением.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param msg - Сообщение об ошибке, используемое когда `result` имеет `Ok`.\n * @returns Распакованное значение ошибки.\n * @throws Error - Выбрасывает исключение, когда `result` имеет `Ok`.\n * @since 0.1.0\n * @see {@link expect} - Симметричный helper для ветки успеха.\n * @example\n * ```ts\n * import { Err, expectErr } from '@resultsafe/core-fp-result';\n *\n * const error = expectErr(Err('boom'), 'must be err');\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const expectErr = <T, E>(result: Result<T, E>, msg: string): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error(msg);\n};\n","import { type Result } from '../shared-types.js';\n\n/**\n * Схлопывает вложенный `Result<Result<T, E>, E>` на один уровень.\n *\n * @typeParam T - The inner success value type.\n * @typeParam E - The shared error value type.\n * @param result - Вложенный `Result` для схлопывания.\n * @returns A single-layer `Result<T, E>`.\n * @since 0.1.0\n * @see {@link andThen} - Chains computations that already return `Result`.\n * @example\n * ```ts\n * import { Ok, flatten } from '@resultsafe/core-fp-result';\n *\n * const value = flatten(Ok(Ok(3)));\n * console.log(value.ok); // true\n * ```\n * @public\n */\nexport const flatten = <T, E>(result: Result<Result<T, E>, E>): Result<T, E> =>\n  result.ok ? result.value : { ok: false, error: result.error };\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Выполняет побочный эффект для успешного значения и возвращает исходный `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция побочного эффекта для ветки успеха.\n * @returns Тот же экземпляр `Result`.\n * @since 0.1.0\n * @see {@link tap} - Эквивалентный helper для ветки успеха.\n * @example\n * ```ts\n * import { Ok, inspect } from '@resultsafe/core-fp-result';\n *\n * const result = inspect(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const inspect = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (isOk(result)) {\n    fn(result.value);\n  }\n  return result;\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Выполняет побочный эффект для значения ошибки и возвращает исходный `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция побочного эффекта для ветки ошибки.\n * @returns Тот же экземпляр `Result`.\n * @since 0.1.0\n * @see {@link tapErr} - Эквивалентный helper для ветки ошибки.\n * @example\n * ```ts\n * import { Err, inspectErr } from '@resultsafe/core-fp-result';\n *\n * const result = inspectErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const inspectErr = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => void,\n): Result<T, E> => {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Преобразует успешное значение, сохраняя ветку ошибки.\n *\n * @typeParam T - Тип входного успешного значения.\n * @typeParam U - Тип выходного успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция преобразования успешного значения.\n * @returns Преобразованный `Ok` или исходный `Err`.\n * @since 0.1.0\n * @see {@link mapErr} - Преобразует ветку ошибки.\n * @example\n * ```ts\n * import { Ok, map } from '@resultsafe/core-fp-result';\n *\n * const result = map(Ok(2), (value) => value * 10);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const map = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => U,\n): Result<U, E> =>\n  isOk(result)\n    ? { ok: true, value: fn(result.value) }\n    : (result as Result<U, E>);\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Преобразует значение ошибки, сохраняя ветку успеха.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип входного значения ошибки.\n * @typeParam F - Тип выходного значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция преобразования значения ошибки.\n * @returns Преобразованный `Err` или исходный `Ok`.\n * @since 0.1.0\n * @see {@link map} - Transforms the success branch.\n * @example\n * ```ts\n * import { Err, mapErr } from '@resultsafe/core-fp-result';\n *\n * const result = mapErr(Err('e1'), (error) => `mapped:${error}`);\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const mapErr = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => F,\n): Result<T, F> =>\n  isErr(result)\n    ? { ok: false, error: fn(result.error) }\n    : (result as Result<T, F>);\n","import { type Result } from '../shared-types.js';\n\n/**\n * Выполняет сопоставление `Result` в единое выходное значение.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @typeParam U - The output type returned by both handlers.\n * @param result - Исходный `Result`.\n * @param okFn - Обработчик для ветки успеха.\n * @param errFn - Обработчик для ветки ошибки.\n * @returns Выходное значение, полученное от выбранного обработчика.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Similar shape with default fallback semantics.\n * @example\n * ```ts\n * import { Ok, match } from '@resultsafe/core-fp-result';\n *\n * const value = match(Ok(3), (x) => `ok:${x}`, (e) => `err:${e}`);\n * console.log(value); // ok:3\n * ```\n * @public\n */\nexport const match = <T, E, U>(\n  result: Result<T, E>,\n  okFn: (value: T) => U,\n  errFn: (error: E) => U,\n): U => {\n  if (result.ok) {\n    return okFn(result.value);\n  } else {\n    const { error } = result;\n    return errFn(error);\n  }\n};\n","import { isOk } from '../guards/isOk.js';\nimport { None, Some } from '../internal/option.js';\nimport { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Извлекает успешную ветку в виде `Option`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns `Some(value)` для `Ok`, иначе `None`.\n * @since 0.1.0\n * @see {@link err} - Извлекает ветку ошибки.\n * @example\n * ```ts\n * import { Ok, ok } from '@resultsafe/core-fp-result';\n *\n * const value = ok(Ok(10));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const ok = <T, E>(result: Result<T, E>): Option<T> =>\n  isOk(result) ? Some(result.value) : None;\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Восстанавливается из ошибки, преобразуя `Err` в другой `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип входного значения ошибки.\n * @typeParam F - Тип выходного значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция восстановления, применяемая для `Err`.\n * @returns Восстановленный `Result` или исходный `Ok`.\n * @since 0.1.0\n * @see {@link andThen} - Цепляет ветку успеха.\n * @example\n * ```ts\n * import { Err, Ok, orElse } from '@resultsafe/core-fp-result';\n *\n * const result = orElse(Err('network'), () => Ok('cached'));\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const orElse = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>,\n): Result<T, F> =>\n  isErr(result) ? fn(result.error) : (result as Result<T, F>);\n","import type { Result } from '../shared-types.js';\n\n/**\n * Выполняет побочный эффект для значения `Ok` и возвращает входной `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Колбэк побочного эффекта для ветки успеха.\n * @returns Неизмененный `Result`.\n * @since 0.1.0\n * @see {@link tapErr} - Executes a side effect for the error branch.\n * @example\n * ```ts\n * import { Ok, tap } from '@resultsafe/core-fp-result';\n *\n * const result = tap(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const tap = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (result.ok) {\n    fn(result.value);\n  }\n  return result;\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Выполняет побочный эффект для значения `Err` и возвращает входной `Result`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Колбэк побочного эффекта для ветки ошибки.\n * @returns Неизмененный `Result`.\n * @since 0.1.0\n * @see {@link tap} - Executes a side effect for the success branch.\n * @example\n * ```ts\n * import { Err, tapErr } from '@resultsafe/core-fp-result';\n *\n * const result = tapErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const tapErr = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => void,\n): Result<T, E> => {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n};\n","import { None, Some } from '../internal/option.js';\nimport { type Option } from '../shared-types.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Преобразует `Result<Option<T>, E>` в `Option<Result<T, E>>`.\n *\n * @typeParam T - The success value type inside `Option`.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`, содержащий `Option`.\n * @returns Транспонированный `Option<Result<T, E>>`.\n * @since 0.1.0\n * @see {@link flatten} - Collapses nested `Result` values.\n * @example\n * ```ts\n * import { Ok, transpose } from '@resultsafe/core-fp-result';\n *\n * const value = transpose(Ok({ some: true, value: 2 }));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const transpose = <T, E>(\n  result: Result<Option<T>, E>,\n): Option<Result<T, E>> => {\n  if (result.ok) {\n    return result.value.some === true\n      ? Some({ ok: true, value: result.value.value })\n      : None;\n  }\n  return Some({ ok: false, error: result.error });\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Возвращает успешное значение или выбрасывает исключение, если результат `Err`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns Payload успеха.\n * @throws Error - Выбрасывает исключение при вызове на `Err`.\n * @since 0.1.0\n * @see {@link unwrapOr} - Возвращает fallback вместо выброса исключения.\n * @example\n * ```ts\n * import { Ok, unwrap } from '@resultsafe/core-fp-result';\n *\n * const value = unwrap(Ok(9));\n * console.log(value); // 9\n * ```\n * @public\n */\nexport const unwrap = <T, E>(result: Result<T, E>): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error('Called unwrap on an Err value');\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Возвращает значение ошибки или выбрасывает исключение, если результат `Ok`.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @returns Payload ошибки.\n * @throws Error - Выбрасывает исключение при вызове на `Ok`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Возвращает fallback успеха без выброса исключения.\n * @example\n * ```ts\n * import { Err, unwrapErr } from '@resultsafe/core-fp-result';\n *\n * const error = unwrapErr(Err('boom'));\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const unwrapErr = <T, E>(result: Result<T, E>): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error('Called unwrapErr on an Ok value');\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../shared-types.js';\n\n/**\n * Возвращает успешное значение или переданный fallback по умолчанию.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param defaultValue - Fallback-значение для `Err`.\n * @returns Payload успеха или `defaultValue`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Вычисляет fallback лениво.\n * @example\n * ```ts\n * import { Err, unwrapOr } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOr(Err('boom'), 0);\n * console.log(value); // 0\n * ```\n * @public\n */\nexport const unwrapOr = <T, E>(result: Result<T, E>, defaultValue: T): T =>\n  isOk(result) ? result.value : defaultValue;\n","import { type Result } from '../shared-types.js';\n\n/**\n * Возвращает успешное значение или вычисляет fallback из ошибки.\n *\n * @typeParam T - Тип успешного значения.\n * @typeParam E - Тип значения ошибки.\n * @param result - Исходный `Result`.\n * @param fn - Функция-поставщик fallback для `Err`.\n * @returns Payload успеха или вычисленный fallback.\n * @since 0.1.0\n * @see {@link unwrapOr} - Использует eager fallback-значение.\n * @example\n * ```ts\n * import { Err, unwrapOrElse } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOrElse(Err('fatal'), (error) => error.length);\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const unwrapOrElse = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => T,\n): T => {\n  if (result.ok) {\n    return result.value;\n  } else {\n    return fn(result.error);\n  }\n};\n","/**\n * Создает runtime type guard для варианта дискриминированного объединения.\n *\n * @typeParam K - The discriminant literal type.\n * @param variant - Значение дискриминанта для сопоставления.\n * @returns A predicate that checks `{ type: K }` shape.\n * @since 0.1.0\n * @see {@link isTypedVariantOf} - Расширяет проверку ключами payload.\n * @example\n * ```ts\n * import { isTypedVariant } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariant('created');\n * console.log(isCreated({ type: 'created' })); // true\n * ```\n * @public\n */\nexport const isTypedVariant =\n  <K extends string>(variant: K) =>\n  (value: unknown): value is { type: K } => {\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    return obj['type'] === variant;\n  };\n","/**\n * Создает runtime type guard для варианта с дополнительными ключами payload.\n *\n * @typeParam K - The discriminant literal type.\n * @typeParam T - The required payload record shape.\n * @param variant - Значение дискриминанта для сопоставления.\n * @returns A predicate that checks variant and payload key presence.\n * @since 0.1.0\n * @see {@link isTypedVariant} - Проверяет только дискриминант.\n * @example\n * ```ts\n * import { isTypedVariantOf } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariantOf<'created', { id: unknown }>('created');\n * console.log(isCreated({ type: 'created', id: 1 })); // true\n * ```\n * @public\n */\nexport const isTypedVariantOf =\n  <K extends string, T extends Record<string, unknown>>(variant: K) =>\n  (value: unknown): value is { type: K } & T => {\n    // Rust-style early returns with Option-like behavior\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    if (obj['type'] !== variant) return false;\n\n    // Type-safe key checking (like Rust's HashMap.contains_key)\n    const requiredKeys = Object.keys({} as T) as Array<keyof T>;\n    for (const key of requiredKeys) {\n      if (!(key in obj)) return false;\n    }\n\n    return true;\n  };\n","import type { Handler, Matcher, VariantOf } from './types/index.js';\n\n/**\n * Создает цепочный matcher для значения дискриминированного объединения.\n *\n * @typeParam T - Тип дискриминированного объединения.\n * @param value - Значение объединения для сопоставления.\n * @returns Fluent matcher с ветками `with` и `otherwise`.\n * @since 0.1.0\n * @see {@link matchVariantStrict} - Требует исчерпывающего сопоставления во время выполнения.\n * @example\n * ```ts\n * import { matchVariant } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariant<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'ok',\n *   value: 1,\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .otherwise(() => 'fallback')\n *   .run();\n *\n * console.log(out); // ok:1\n * ```\n * @public\n */\nexport const matchVariant = <T extends VariantOf>(\n  value: T,\n): Matcher<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const withHandler = <K extends T['type']>(\n    variant: K,\n    fn: (value: Extract<T, { type: K }>) => unknown,\n  ): Matcher<T, unknown> => {\n    const newHandlers = [...handlers, { variant, fn }] as const;\n\n    return {\n      with: <K2 extends T['type']>(\n        variant2: K2,\n        fn2: (value: Extract<T, { type: K2 }>) => unknown,\n      ): Matcher<T, unknown> => {\n        const newerHandlers = [\n          ...newHandlers,\n          { variant: variant2, fn: fn2 },\n        ] as const;\n\n        return {\n          with: withHandler,\n          otherwise: (fallback: (value: T) => unknown) => ({\n            run: (): unknown => {\n              for (const h of newerHandlers) {\n                if (value.type === h.variant) {\n                  const fn = h.fn as (input: T) => unknown;\n                  return fn(value);\n                }\n              }\n              return fallback(value);\n            },\n          }),\n        } as Matcher<T, unknown>;\n      },\n      otherwise: (fallback: (value: T) => unknown) => ({\n        run: (): unknown => {\n          for (const h of newHandlers) {\n            if (value.type === h.variant) {\n              const fn = h.fn as (input: T) => unknown;\n              return fn(value);\n            }\n          }\n          return fallback(value);\n        },\n      }),\n    } as Matcher<T, unknown>;\n  };\n\n  const matcher: Matcher<T, unknown> = {\n    with: withHandler,\n    otherwise: (fallback: (value: T) => unknown) => ({\n      run: (): unknown => {\n        /* v8 ignore start -- unreachable with current immutable root handler list */\n        for (const h of handlers) {\n          if (value.type === h.variant) {\n            const fn = h.fn as (input: T) => unknown;\n            return fn(value);\n          }\n        }\n        /* v8 ignore stop */\n        return fallback(value);\n      },\n    }),\n  };\n\n  return matcher;\n};\n","import type { Handler, MatchBuilder, VariantOf } from './types/index.js';\n\n/**\n * Создает строгий matcher, выбрасывающий исключение для необработанных вариантов.\n *\n * @typeParam T - Тип дискриминированного объединения.\n * @param value - Значение объединения для сопоставления.\n * @returns Строгий builder сопоставления, требующий явных обработчиков.\n * @throws Error - Выбрасывает исключение, если ни один зарегистрированный обработчик не соответствует `value.type`.\n * @since 0.1.0\n * @see {@link matchVariant} - Использует fallback-ветку вместо выброса исключения.\n * @example\n * ```ts\n * import { matchVariantStrict } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariantStrict<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'err',\n *   error: 'boom',\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .with('err', (v) => `err:${v.error}`)\n *   .run();\n *\n * console.log(out); // err:boom\n * ```\n * @public\n */\nexport const matchVariantStrict = <T extends VariantOf>(\n  value: T,\n): MatchBuilder<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const builder = <Handled extends T['type'] = never>(): MatchBuilder<\n    T,\n    unknown,\n    Handled\n  > => ({\n    with: <K extends Exclude<T['type'], Handled>>(\n      variant: K,\n      fn: (value: Extract<T, { type: K }>) => unknown,\n    ) => {\n      const newHandlers = [...handlers, { variant, fn }] as const;\n\n      return {\n        with: builder<Handled | K>().with,\n        run: (() => {\n          for (const h of newHandlers) {\n            if (value.type === h.variant) {\n              const fn = h.fn as (input: T) => unknown;\n              return fn(value);\n            }\n          }\n          throw new Error(\n            `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n          );\n        }) as Handled extends T['type'] ? () => unknown : never,\n      } as MatchBuilder<T, unknown, Handled | K>;\n    },\n\n    run: (() => {\n      /* v8 ignore start -- unreachable with current immutable root handler list */\n      for (const h of handlers) {\n        if (value.type === h.variant) {\n          const fn = h.fn as (input: T) => unknown;\n          return fn(value);\n        }\n      }\n      /* v8 ignore stop */\n      throw new Error(\n        `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n      );\n    }) as Handled extends T['type'] ? () => unknown : never,\n  });\n\n  return builder();\n};\n","/** Checks that an object owns a property key. @internal */\nexport const hasOwn = <K extends PropertyKey>(\n  obj: Record<string, unknown>,\n  key: K,\n): obj is Record<K, unknown> => Object.prototype.hasOwnProperty.call(obj, key);\n\n/** Checks that a value is a non-null object record. @internal */\nexport const isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null;\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type {\n  AsyncValidatorFn,\n  PayloadKeys,\n  VariantConfig,\n} from '../shared-types.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Создает асинхронный refiner варианта с асинхронными валидаторами payload.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @param variantMap - Карта, описывающая допустимые варианты и поля payload.\n * @returns A curried async refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineAsyncResultU} - Непосредственный (не-curry) вариант helper.\n * @example\n * ```ts\n * import { refineAsyncResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineAsyncResult(map)('ok')({\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(await refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineAsyncResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  async (\n    value: unknown,\n  ): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      const isValid = await check(field); // ✅ Асинхронная валидация\n      if (!isValid) return null;\n    }\n\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Уточняет значение асинхронно в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта асинхронных валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Асинхронные валидаторы payload.\n * @returns Промис с уточненным значением или `null`.\n * @remarks\n * This export is kept for compatibility. Prefer {@link refineAsyncResultU}\n * from `refineAsyncResultU.ts` как каноническую точку входа без curry.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result/src/refiners/refineAsyncResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> =>\n  refineAsyncResult(variantMap)(variant)(validators)(value);\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type {\n  AsyncValidatorFn,\n  PayloadKeys,\n  VariantConfig,\n} from '../shared-types.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Уточняет значение асинхронно в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта асинхронных валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Асинхронные валидаторы payload.\n * @returns Промис с уточненным значением или `null`.\n * @since 0.1.0\n * @see {@link refineAsyncResult} - Curry-конструктор асинхронного refiner.\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n  // Императивный стиль с early returns (как в Rust)\n  return (async () => {\n    // Rust-style early returns с Option-like поведением\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    // Payload validation с асинхронными валидаторами\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators[key as keyof TValidators];\n      if (!check) continue;\n\n      const field = value[key as string];\n      // Type-safe async validation\n      const isValid = await (check as AsyncValidatorFn)(field);\n      if (!isValid) return null;\n    }\n\n    // Safe cast после всех проверок\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  })();\n};\n","import type { PayloadKeys, VariantConfig } from '../../shared-types.js';\n\n/**\n * Нормализует конфигурацию payload варианта в список ключей.\n *\n * @typeParam C - Тип конфигурации варианта.\n * @param config - Конфигурация варианта с определением payload.\n * @returns Ключи payload как readonly-массив.\n * @since 0.1.0\n * @example\n * ```ts\n * import { getPayloadKeys } from '@resultsafe/core-fp-result/src/refiners/utils/getPayloadKeys.js';\n *\n * const keys = getPayloadKeys({ payload: ['id', 'meta'] } as const);\n * console.log(keys.length); // 2\n * ```\n * @internal\n */\nexport const getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\nimport type { UniversalRefinedResult } from './types/index.js';\nimport { getPayloadKeys } from './utils/index.js';\n\n/**\n * Создает синхронный refiner варианта с валидаторами payload.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @param variantMap - Карта, описывающая допустимые варианты и поля payload.\n * @returns A curried refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineResultU} - Непосредственный (не-curry) вариант helper.\n * @example\n * ```ts\n * import { refineResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineResult(map)('ok')({\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  (value: unknown): UniversalRefinedResult<K, TMap, TValidators> | null => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      if (!check(field)) return null;\n    }\n\n    return value as UniversalRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Уточняет значение по карте вариантов в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Валидаторы payload для целевого варианта.\n * @returns Уточненное значение или `null`.\n * @remarks\n * Этот экспорт сохранен для совместимости. Предпочитайте {@link refineResultU} из\n * `refineResultU.ts` как каноническую точку входа без curry.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result/src/refiners/refineResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): UniversalRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n","import type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\nimport { refineResult } from './refineResult.js';\nimport type { SyncRefinedResult } from './types/index.js';\n\n/**\n * Уточняет значение по карте вариантов в не-curry стиле вызова.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam K - Ключ целевого варианта.\n * @typeParam TValidators - Карта валидаторов для полей payload.\n * @param value - Значение для валидации и уточнения.\n * @param variant - Ключ целевого варианта.\n * @param variantMap - Карта конфигурации вариантов.\n * @param validators - Валидаторы payload для целевого варианта.\n * @returns Уточненное значение или `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Curry-конструктор refiner.\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n","import type {\n  PayloadKeys,\n  ValidatorFn,\n  VariantConfig,\n} from '../shared-types.js';\nimport type { SyncRefinedResultUnion } from './types/SyncRefinedResultUnion.js';\nimport type { SyncValidatorMap } from './types/SyncValidatorMap.js';\n\n/**\n * Уточняет значение дискриминированного объединения по полной карте вариантов.\n *\n * @typeParam TMap - Тип карты конфигурации вариантов.\n * @typeParam TValidators - Тип карты валидаторов по вариантам.\n * @param value - Значение для валидации и уточнения.\n * @param variantMap - Полная карта конфигурации вариантов.\n * @param validators - Валидаторы, сгруппированные по ключу варианта.\n * @returns Уточненный элемент объединения или `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Refines one concrete variant key.\n * @example\n * ```ts\n * import { refineVariantMap } from '@resultsafe/core-fp-result';\n *\n * const map = {\n *   created: { payload: 'id' },\n *   failed: { payload: 'reason' },\n * } as const;\n *\n * const out = refineVariantMap({ type: 'created', id: '1' }, map, {\n *   created: { id: (x: unknown): x is string => typeof x === 'string' },\n *   failed: { reason: (x: unknown): x is string => typeof x === 'string' },\n * });\n *\n * console.log(out?.type); // created\n * ```\n * @public\n */\nexport function refineVariantMap<\n  TMap extends Record<string, VariantConfig>,\n  TValidators extends SyncValidatorMap<TMap>,\n>(\n  value: unknown,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResultUnion<TMap, TValidators> | null {\n  if (typeof value !== 'object' || value === null || !('type' in value)) {\n    return null;\n  }\n\n  const rawType = (value as { type?: unknown }).type;\n  if (typeof rawType !== 'string' || !(rawType in variantMap)) return null;\n\n  // фиксируем конкретный ключ варианта\n  type K = Extract<keyof TMap, string>;\n  const k = rawType as K;\n\n  const config = variantMap[k];\n  if (!config) return null;\n\n  // ключи payload для конкретного K\n  const payload = config.payload;\n  const keys = (\n    payload === 'never' ? [] : Array.isArray(payload) ? payload : [payload]\n  ) as readonly PayloadKeys<TMap[typeof k]>[];\n\n  // валидаторы, согласованные с конкретным K\n  const vvs = validators[k] as\n    | Partial<Record<PayloadKeys<TMap[typeof k]>, ValidatorFn>>\n    | undefined;\n\n  if (vvs) {\n    const obj = value as Record<string, unknown>;\n    for (const key of keys) {\n      const check = vvs[key];\n      if (!check) continue;\n      if (!check(obj[key as string])) return null;\n    }\n  }\n\n  return value as SyncRefinedResultUnion<TMap, TValidators>;\n}\n"],"names":["fn","getPayloadKeys"],"mappings":"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"}
+{"version":3,"file":"resultsafe-monorepo-core-fp-result.umd.js","sources":["../../src/constructors/Err.ts","../../src/constructors/Ok.ts","../../src/guards/isErr.ts","../../src/guards/isErrAnd.ts","../../src/guards/isOk.ts","../../src/guards/isOkAnd.ts","../../src/methods/andThen.ts","../../src/internal/option.ts","../../src/methods/err.ts","../../src/methods/expect.ts","../../src/methods/expectErr.ts","../../src/methods/flatten.ts","../../src/methods/inspect.ts","../../src/methods/inspectErr.ts","../../src/methods/map.ts","../../src/methods/mapErr.ts","../../src/methods/match.ts","../../src/methods/ok.ts","../../src/methods/orElse.ts","../../src/methods/tap.ts","../../src/methods/tapErr.ts","../../src/methods/transpose.ts","../../src/methods/unwrap.ts","../../src/methods/unwrapErr.ts","../../src/methods/unwrapOr.ts","../../src/methods/unwrapOrElse.ts","../../src/refiners/isTypedVariant.ts","../../src/refiners/isTypedVariantOf.ts","../../src/refiners/matchVariant.ts","../../src/refiners/matchVariantStrict.ts","../../src/internal/object.ts","../../src/refiners/refineAsyncResult.ts","../../src/refiners/refineAsyncResultU.ts","../../src/refiners/utils/getPayloadKeys.ts","../../src/refiners/refineResult.ts","../../src/refiners/refineResultU.ts","../../src/refiners/refineVariantMap.ts"],"sourcesContent":["import type { Result } from '../types/core/index.js';\n\n/**\n * Creates an error `Result` value from the provided error payload.\n *\n * @typeParam E - The error value type.\n * @typeParam T - The success type for the resulting `Result`.\n * @param error - The error payload to wrap.\n * @returns A `Result` with `ok: false` and the provided `error`.\n * @since 0.1.0\n * @see {@link Ok} - Creates a successful `Result`.\n * @example\n * ```ts\n * import { Err } from '@resultsafe/core-fp-result';\n *\n * const result = Err<string, number>('boom');\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const Err = <E, T = never>(error: E): Result<T, E> =>\n  ({ ok: false, error }) as const;\n","import type { Result } from '../types/core/index.js';\n\n/**\n * Creates a successful `Result` value from the provided payload.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error type for the resulting `Result`.\n * @param value - The success payload to wrap.\n * @returns A `Result` with `ok: true` and the provided `value`.\n * @since 0.1.0\n * @see {@link Err} - Creates an error `Result`.\n * @example\n * ```ts\n * import { Ok } from '@resultsafe/core-fp-result';\n *\n * const result = Ok<number, string>(42);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const Ok = <T, E = never>(value: T): Result<T, E> =>\n  ({ ok: true, value }) as const;\n","import type { Result } from '../types/core/index.js';\n\n/**\n * Checks whether the `Result` is in the error branch.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The `Result` to check.\n * @returns `true` when `result.ok` equals `false`.\n * @since 0.1.0\n * @see {@link isOk} - Checks the success branch.\n * @example\n * ```ts\n * import { Err, isErr } from '@resultsafe/core-fp-result';\n *\n * const result = Err('boom');\n * console.log(isErr(result)); // true\n * ```\n * @public\n */\nexport const isErr = <T, E>(\n  result: Result<T, E>,\n): result is { ok: false; error: E } => result.ok === false;\n","import { type Result } from '../types/core/index.js';\nimport { isErr } from './isErr.js';\n\n/**\n * Checks that the `Result` resulted in an error and satisfies the predicate.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The `Result` to check.\n * @param predicate - The predicate applied to the error value.\n * @returns `true` when the value is `Err` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isErr} - Performs the base error check.\n * @example\n * ```ts\n * import { Err, isErrAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Err({ code: 503 });\n * console.log(isErrAnd(result, (error) => error.code >= 500)); // true\n * ```\n * @public\n */\nexport const isErrAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (error: E) => boolean,\n): boolean => isErr(result) && predicate(result.error);\n","import type { Result } from '../types/core/index.js';\n\n/**\n * Checks whether a `Result` is in the success branch.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The `Result` to check.\n * @returns `true` when `result.ok` equals `true`.\n * @since 0.1.0\n * @see {@link isErr} - Checks the error branch.\n * @example\n * ```ts\n * import { Ok, isOk } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(10);\n * console.log(isOk(result)); // true\n * ```\n * @public\n */\nexport const isOk = <T, E>(\n  result: Result<T, E>,\n): result is { ok: true; value: T } => result.ok === true;\n","import { type Result } from '../types/core/index.js';\nimport { isOk } from './isOk.js';\n\n/**\n * Checks that the `Result` is successful and satisfies the predicate.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The `Result` to check.\n * @param predicate - The predicate applied to the success value.\n * @returns `true` when the value is `Ok` and the predicate returns `true`.\n * @since 0.1.0\n * @see {@link isOk} - Performs the base success check.\n * @example\n * ```ts\n * import { Ok, isOkAnd } from '@resultsafe/core-fp-result';\n *\n * const result = Ok(8);\n * console.log(isOkAnd(result, (value) => value % 2 === 0)); // true\n * ```\n * @public\n */\nexport const isOkAnd = <T, E>(\n  result: Result<T, E>,\n  predicate: (value: T) => boolean,\n): boolean => isOk(result) && predicate(result.value);\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Chains a computation that returns another `Result`.\n *\n * @typeParam T - The input success type.\n * @typeParam U - The output success type.\n * @typeParam E - The shared error type.\n * @param result - The source `Result`.\n * @param fn - The function applied when `result` is `Ok`.\n * @returns The transformed `Result` or the original `Err`.\n * @since 0.1.0\n * @see {@link map} - Transforms only the success value.\n * @example\n * ```ts\n * import { Ok, Err, andThen } from '@resultsafe/core-fp-result';\n *\n * const parsed = andThen(Ok('12'), (value) => {\n *   const n = Number(value);\n *   return Number.isNaN(n) ? Err('invalid') : Ok(n);\n * });\n * console.log(parsed.ok); // true\n * ```\n * @public\n */\nexport const andThen = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => Result<U, E>,\n): Result<U, E> => (isOk(result) ? fn(result.value) : (result as Result<U, E>));\n","/** Represents an empty internal option value. @internal */\nexport const None = { some: false } as const;\n\n/** Wraps an internal option value as present. @internal */\nexport const Some = <T>(value: T) => ({ some: true, value }) as const;\n","import { isErr } from '../guards/isErr.js';\nimport { None, Some } from '../internal/option.js';\nimport { type Option, type Result } from '../types/core/index.js';\n\n/**\n * Extracts the error branch as an `Option`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @returns `Some(error)` for `Err`, otherwise `None`.\n * @since 0.1.0\n * @see {@link ok} - Extracts the success branch.\n * @example\n * ```ts\n * import { Err, err } from '@resultsafe/core-fp-result';\n *\n * const value = err(Err('boom'));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const err = <T, E>(result: Result<T, E>): Option<E> =>\n  isErr(result) ? Some(result.error) : None;\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Returns the success value or throws an exception with a custom message.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param msg - The error message used when `result` is `Err`.\n * @returns The unwrapped success value.\n * @throws Error - Throws an exception when `result` is `Err`.\n * @since 0.1.0\n * @see {@link expectErr} - Symmetric helper for the error branch.\n * @example\n * ```ts\n * import { Ok, expect } from '@resultsafe/core-fp-result';\n *\n * const value = expect(Ok(5), 'must be ok');\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const expect = <T, E>(result: Result<T, E>, msg: string): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error(msg);\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Returns the error value or throws an exception with a custom message.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param msg - The error message used when `result` is `Ok`.\n * @returns The unwrapped error value.\n * @throws Error - Throws an exception when `result` is `Ok`.\n * @since 0.1.0\n * @see {@link expect} - Symmetric helper for the success branch.\n * @example\n * ```ts\n * import { Err, expectErr } from '@resultsafe/core-fp-result';\n *\n * const error = expectErr(Err('boom'), 'must be err');\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const expectErr = <T, E>(result: Result<T, E>, msg: string): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error(msg);\n};\n","import { type Result } from '../types/core/index.js';\n\n/**\n * Collapses a nested `Result<Result<T, E>, E>` one level.\n *\n * @typeParam T - The inner success value type.\n * @typeParam E - The shared error value type.\n * @param result - The nested `Result` to collapse.\n * @returns A single-layer `Result<T, E>`.\n * @since 0.1.0\n * @see {@link andThen} - Chains computations that already return `Result`.\n * @example\n * ```ts\n * import { Ok, flatten } from '@resultsafe/core-fp-result';\n *\n * const value = flatten(Ok(Ok(3)));\n * console.log(value.ok); // true\n * ```\n * @public\n */\nexport const flatten = <T, E>(result: Result<Result<T, E>, E>): Result<T, E> =>\n  result.ok ? result.value : { ok: false, error: result.error };\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Performs a side effect for the success value and returns the original `Result`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The side effect function for the success branch.\n * @returns The same `Result` instance.\n * @since 0.1.0\n * @see {@link tap} - Equivalent helper for the success branch.\n * @example\n * ```ts\n * import { Ok, inspect } from '@resultsafe/core-fp-result';\n *\n * const result = inspect(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const inspect = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (isOk(result)) {\n    fn(result.value);\n  }\n  return result;\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Performs a side effect for the error value and returns the original `Result`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The side effect function for the error branch.\n * @returns The same `Result` instance.\n * @since 0.1.0\n * @see {@link tapErr} - Equivalent helper for the error branch.\n * @example\n * ```ts\n * import { Err, inspectErr } from '@resultsafe/core-fp-result';\n *\n * const result = inspectErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const inspectErr = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => void,\n): Result<T, E> => {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Transforms the success value while preserving the error branch.\n *\n * @typeParam T - The input success value type.\n * @typeParam U - The output success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The transformation function for the success value.\n * @returns The transformed `Ok` or the original `Err`.\n * @since 0.1.0\n * @see {@link mapErr} - Transforms the error branch.\n * @example\n * ```ts\n * import { Ok, map } from '@resultsafe/core-fp-result';\n *\n * const result = map(Ok(2), (value) => value * 10);\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const map = <T, U, E>(\n  result: Result<T, E>,\n  fn: (value: T) => U,\n): Result<U, E> =>\n  isOk(result)\n    ? { ok: true, value: fn(result.value) }\n    : (result as Result<U, E>);\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Transforms the error value while preserving the success branch.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The input error value type.\n * @typeParam F - The output error value type.\n * @param result - The source `Result`.\n * @param fn - The transformation function for the error value.\n * @returns The transformed `Err` or the original `Ok`.\n * @since 0.1.0\n * @see {@link map} - Transforms the success branch.\n * @example\n * ```ts\n * import { Err, mapErr } from '@resultsafe/core-fp-result';\n *\n * const result = mapErr(Err('e1'), (error) => `mapped:${error}`);\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const mapErr = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => F,\n): Result<T, F> =>\n  isErr(result)\n    ? { ok: false, error: fn(result.error) }\n    : (result as Result<T, F>);\n","import { type Result } from '../types/core/index.js';\n\n/**\n * Pattern matches the `Result` into a single output value.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @typeParam U - The output type returned by both handlers.\n * @param result - The source `Result`.\n * @param okFn - The handler for the success branch.\n * @param errFn - The handler for the error branch.\n * @returns The output value produced by the selected handler.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Similar shape with default fallback semantics.\n * @example\n * ```ts\n * import { Ok, match } from '@resultsafe/core-fp-result';\n *\n * const value = match(Ok(3), (x) => `ok:${x}`, (e) => `err:${e}`);\n * console.log(value); // ok:3\n * ```\n * @public\n */\nexport const match = <T, E, U>(\n  result: Result<T, E>,\n  okFn: (value: T) => U,\n  errFn: (error: E) => U,\n): U => {\n  if (result.ok) {\n    return okFn(result.value);\n  } else {\n    const { error } = result;\n    return errFn(error);\n  }\n};\n","import { isOk } from '../guards/isOk.js';\nimport { None, Some } from '../internal/option.js';\nimport { type Option, type Result } from '../types/core/index.js';\n\n/**\n * Extracts the success branch as an `Option`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @returns `Some(value)` for `Ok`, otherwise `None`.\n * @since 0.1.0\n * @see {@link err} - Extracts the error branch.\n * @example\n * ```ts\n * import { Ok, ok } from '@resultsafe/core-fp-result';\n *\n * const value = ok(Ok(10));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const ok = <T, E>(result: Result<T, E>): Option<T> =>\n  isOk(result) ? Some(result.value) : None;\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Recovers from an error by transforming `Err` into another `Result`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The input error value type.\n * @typeParam F - The output error value type.\n * @param result - The source `Result`.\n * @param fn - The recovery function applied to `Err`.\n * @returns The recovered `Result` or the original `Ok`.\n * @since 0.1.0\n * @see {@link andThen} - Chains the success branch.\n * @example\n * ```ts\n * import { Err, Ok, orElse } from '@resultsafe/core-fp-result';\n *\n * const result = orElse(Err('network'), () => Ok('cached'));\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const orElse = <T, E, F>(\n  result: Result<T, E>,\n  fn: (error: E) => Result<T, F>,\n): Result<T, F> =>\n  isErr(result) ? fn(result.error) : (result as Result<T, F>);\n","import type { Result } from '../types/core/index.js';\n\n/**\n * Performs a side effect for the `Ok` value and returns the input `Result`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The side effect callback for the success branch.\n * @returns The unchanged `Result`.\n * @since 0.1.0\n * @see {@link tapErr} - Executes a side effect for the error branch.\n * @example\n * ```ts\n * import { Ok, tap } from '@resultsafe/core-fp-result';\n *\n * const result = tap(Ok(1), (value) => console.log(value)); // 1\n * console.log(result.ok); // true\n * ```\n * @public\n */\nexport const tap = <T, E>(\n  result: Result<T, E>,\n  fn: (value: T) => void,\n): Result<T, E> => {\n  if (result.ok) {\n    fn(result.value);\n  }\n  return result;\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Performs a side effect for the `Err` value and returns the input `Result`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The side effect callback for the error branch.\n * @returns The unchanged `Result`.\n * @since 0.1.0\n * @see {@link tap} - Executes a side effect for the success branch.\n * @example\n * ```ts\n * import { Err, tapErr } from '@resultsafe/core-fp-result';\n *\n * const result = tapErr(Err('boom'), (error) => console.log(error)); // boom\n * console.log(result.ok); // false\n * ```\n * @public\n */\nexport const tapErr = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => void,\n): Result<T, E> => {\n  if (isErr(result)) {\n    fn(result.error);\n  }\n  return result;\n};\n","import { None, Some } from '../internal/option.js';\nimport { type Option, type Result } from '../types/core/index.js';\n\n/**\n * Transforms `Result<Option<T>, E>` into `Option<Result<T, E>>`.\n *\n * @typeParam T - The success value type inside `Option`.\n * @typeParam E - The error value type.\n * @param result - The source `Result` containing an `Option`.\n * @returns The transposed `Option<Result<T, E>>`.\n * @since 0.1.0\n * @see {@link flatten} - Collapses nested `Result` values.\n * @example\n * ```ts\n * import { Ok, transpose } from '@resultsafe/core-fp-result';\n *\n * const value = transpose(Ok({ some: true, value: 2 }));\n * console.log(value.some); // true\n * ```\n * @public\n */\nexport const transpose = <T, E>(\n  result: Result<Option<T>, E>,\n): Option<Result<T, E>> => {\n  if (result.ok) {\n    return result.value.some === true\n      ? Some({ ok: true, value: result.value.value })\n      : None;\n  }\n  return Some({ ok: false, error: result.error });\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Returns the success value or throws an exception if the result is `Err`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @returns The success payload.\n * @throws Error - Throws an exception when called on `Err`.\n * @since 0.1.0\n * @see {@link unwrapOr} - Returns a fallback instead of throwing.\n * @example\n * ```ts\n * import { Ok, unwrap } from '@resultsafe/core-fp-result';\n *\n * const value = unwrap(Ok(9));\n * console.log(value); // 9\n * ```\n * @public\n */\nexport const unwrap = <T, E>(result: Result<T, E>): T => {\n  if (isOk(result)) {\n    return result.value;\n  }\n  throw new Error('Called unwrap on an Err value');\n};\n","import { isErr } from '../guards/isErr.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Returns the error value or throws an exception if the result is `Ok`.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @returns The error payload.\n * @throws Error - Throws an exception when called on `Ok`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Returns a success fallback without throwing.\n * @example\n * ```ts\n * import { Err, unwrapErr } from '@resultsafe/core-fp-result';\n *\n * const error = unwrapErr(Err('boom'));\n * console.log(error); // boom\n * ```\n * @public\n */\nexport const unwrapErr = <T, E>(result: Result<T, E>): E => {\n  if (isErr(result)) {\n    return result.error;\n  }\n  throw new Error('Called unwrapErr on an Ok value');\n};\n","import { isOk } from '../guards/isOk.js';\nimport { type Result } from '../types/core/index.js';\n\n/**\n * Returns the success value or the provided default fallback.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param defaultValue - The fallback value for `Err`.\n * @returns The success payload or `defaultValue`.\n * @since 0.1.0\n * @see {@link unwrapOrElse} - Computes the fallback lazily.\n * @example\n * ```ts\n * import { Err, unwrapOr } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOr(Err('boom'), 0);\n * console.log(value); // 0\n * ```\n * @public\n */\nexport const unwrapOr = <T, E>(result: Result<T, E>, defaultValue: T): T =>\n  isOk(result) ? result.value : defaultValue;\n","import { type Result } from '../types/core/index.js';\n\n/**\n * Returns the success value or computes a fallback from the error.\n *\n * @typeParam T - The success value type.\n * @typeParam E - The error value type.\n * @param result - The source `Result`.\n * @param fn - The fallback provider function for `Err`.\n * @returns The success payload or the computed fallback.\n * @since 0.1.0\n * @see {@link unwrapOr} - Uses an eager fallback value.\n * @example\n * ```ts\n * import { Err, unwrapOrElse } from '@resultsafe/core-fp-result';\n *\n * const value = unwrapOrElse(Err('fatal'), (error) => error.length);\n * console.log(value); // 5\n * ```\n * @public\n */\nexport const unwrapOrElse = <T, E>(\n  result: Result<T, E>,\n  fn: (error: E) => T,\n): T => {\n  if (result.ok) {\n    return result.value;\n  } else {\n    return fn(result.error);\n  }\n};\n","/**\n * Creates a runtime type guard for a discriminated union variant.\n *\n * @typeParam K - The discriminant literal type.\n * @param variant - The discriminant value to match.\n * @returns A predicate that checks `{ type: K }` shape.\n * @since 0.1.0\n * @see {@link isTypedVariantOf} - Extends check with payload keys.\n * @example\n * ```ts\n * import { isTypedVariant } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariant('created');\n * console.log(isCreated({ type: 'created' })); // true\n * ```\n * @public\n */\nexport const isTypedVariant =\n  <K extends string>(variant: K) =>\n  (value: unknown): value is { type: K } => {\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    return obj['type'] === variant;\n  };\n","/**\n * Creates a runtime type guard for a variant with additional payload keys.\n *\n * @typeParam K - The discriminant literal type.\n * @typeParam T - The required payload record shape.\n * @param variant - The discriminant value to match.\n * @returns A predicate that checks variant and payload key presence.\n * @since 0.1.0\n * @see {@link isTypedVariant} - Checks only the discriminant.\n * @example\n * ```ts\n * import { isTypedVariantOf } from '@resultsafe/core-fp-result';\n *\n * const isCreated = isTypedVariantOf<'created', { id: unknown }>('created');\n * console.log(isCreated({ type: 'created', id: 1 })); // true\n * ```\n * @public\n */\nexport const isTypedVariantOf =\n  <K extends string, T extends Record<string, unknown>>(variant: K) =>\n  (value: unknown): value is { type: K } & T => {\n    // Rust-style early returns with Option-like behavior\n    if (typeof value !== 'object' || value === null) return false;\n    if (!('type' in value)) return false;\n\n    const obj = value as Record<string, unknown>;\n    if (obj['type'] !== variant) return false;\n\n    // Type-safe key checking (like Rust's HashMap.contains_key)\n    const requiredKeys = Object.keys({} as T) as Array<keyof T>;\n    for (const key of requiredKeys) {\n      if (!(key in obj)) return false;\n    }\n\n    return true;\n  };\n","import type { Handler, Matcher, VariantOf } from './types/index.js';\n\n/**\n * Creates a chained matcher for a discriminated union value.\n *\n * @typeParam T - The discriminated union type.\n * @param value - The union value to match.\n * @returns A fluent matcher with `with` and `otherwise` branches.\n * @since 0.1.0\n * @see {@link matchVariantStrict} - Requires exhaustive matching at runtime.\n * @example\n * ```ts\n * import { matchVariant } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariant<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'ok',\n *   value: 1,\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .otherwise(() => 'fallback')\n *   .run();\n *\n * console.log(out); // ok:1\n * ```\n * @public\n */\nexport const matchVariant = <T extends VariantOf>(\n  value: T,\n): Matcher<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const withHandler = <K extends T['type']>(\n    variant: K,\n    fn: (value: Extract<T, { type: K }>) => unknown,\n  ): Matcher<T, unknown> => {\n    const newHandlers = [...handlers, { variant, fn }] as const;\n\n    return {\n      with: <K2 extends T['type']>(\n        variant2: K2,\n        fn2: (value: Extract<T, { type: K2 }>) => unknown,\n      ): Matcher<T, unknown> => {\n        const newerHandlers = [\n          ...newHandlers,\n          { variant: variant2, fn: fn2 },\n        ] as const;\n\n        return {\n          with: withHandler,\n          otherwise: (fallback: (value: T) => unknown) => ({\n            run: (): unknown => {\n              for (const h of newerHandlers) {\n                if (value.type === h.variant) {\n                  const fn = h.fn as (input: T) => unknown;\n                  return fn(value);\n                }\n              }\n              return fallback(value);\n            },\n          }),\n        } as Matcher<T, unknown>;\n      },\n      otherwise: (fallback: (value: T) => unknown) => ({\n        run: (): unknown => {\n          for (const h of newHandlers) {\n            if (value.type === h.variant) {\n              const fn = h.fn as (input: T) => unknown;\n              return fn(value);\n            }\n          }\n          return fallback(value);\n        },\n      }),\n    } as Matcher<T, unknown>;\n  };\n\n  const matcher: Matcher<T, unknown> = {\n    with: withHandler,\n    otherwise: (fallback: (value: T) => unknown) => ({\n      run: (): unknown => {\n        /* v8 ignore start -- unreachable with current immutable root handler list */\n        for (const h of handlers) {\n          if (value.type === h.variant) {\n            const fn = h.fn as (input: T) => unknown;\n            return fn(value);\n          }\n        }\n        /* v8 ignore stop */\n        return fallback(value);\n      },\n    }),\n  };\n\n  return matcher;\n};\n","import type { Handler, MatchBuilder, VariantOf } from './types/index.js';\n\n/**\n * Creates a strict matcher that throws an exception for unhandled variants.\n *\n * @typeParam T - The discriminated union type.\n * @param value - The union value to match.\n * @returns A strict match builder requiring explicit handlers.\n * @throws Error - Throws an exception if no registered handler matches `value.type`.\n * @since 0.1.0\n * @see {@link matchVariant} - Uses a fallback branch instead of throwing.\n * @example\n * ```ts\n * import { matchVariantStrict } from '@resultsafe/core-fp-result';\n *\n * const out = matchVariantStrict<{ type: 'ok'; value: number } | { type: 'err'; error: string }>({\n *   type: 'err',\n *   error: 'boom',\n * })\n *   .with('ok', (v) => `ok:${v.value}`)\n *   .with('err', (v) => `err:${v.error}`)\n *   .run();\n *\n * console.log(out); // err:boom\n * ```\n * @public\n */\nexport const matchVariantStrict = <T extends VariantOf>(\n  value: T,\n): MatchBuilder<T, unknown> => {\n  const handlers: readonly Handler<T['type'], T, unknown>[] = [];\n\n  const builder = <Handled extends T['type'] = never>(): MatchBuilder<\n    T,\n    unknown,\n    Handled\n  > => ({\n    with: <K extends Exclude<T['type'], Handled>>(\n      variant: K,\n      fn: (value: Extract<T, { type: K }>) => unknown,\n    ) => {\n      const newHandlers = [...handlers, { variant, fn }] as const;\n\n      return {\n        with: builder<Handled | K>().with,\n        run: (() => {\n          for (const h of newHandlers) {\n            if (value.type === h.variant) {\n              const fn = h.fn as (input: T) => unknown;\n              return fn(value);\n            }\n          }\n          throw new Error(\n            `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n          );\n        }) as Handled extends T['type'] ? () => unknown : never,\n      } as MatchBuilder<T, unknown, Handled | K>;\n    },\n\n    run: (() => {\n      /* v8 ignore start -- unreachable with current immutable root handler list */\n      for (const h of handlers) {\n        if (value.type === h.variant) {\n          const fn = h.fn as (input: T) => unknown;\n          return fn(value);\n        }\n      }\n      /* v8 ignore stop */\n      throw new Error(\n        `Unmatched variant: ${String((value as { type: unknown }).type)}`,\n      );\n    }) as Handled extends T['type'] ? () => unknown : never,\n  });\n\n  return builder();\n};\n","/** Checks that an object owns a property key. @internal */\nexport const hasOwn = <K extends PropertyKey>(\n  obj: Record<string, unknown>,\n  key: K,\n): obj is Record<K, unknown> => Object.prototype.hasOwnProperty.call(obj, key);\n\n/** Checks that a value is a non-null object record. @internal */\nexport const isObject = (value: unknown): value is Record<string, unknown> =>\n  typeof value === 'object' && value !== null;\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type { AsyncValidatorFn } from '../types/refiners/AsyncValidatorFn.js';\nimport type { PayloadKeys } from '../types/refiners/PayloadKeys.js';\nimport type { VariantConfig } from '../types/refiners/VariantConfig.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Creates an async variant refiner with async payload validators.\n *\n * @typeParam TMap - The variant configuration map type.\n * @param variantMap - The map describing valid variants and payload fields.\n * @returns A curried async refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineAsyncResultU} - Direct (non-curried) helper variant.\n * @example\n * ```ts\n * import { refineAsyncResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineAsyncResult(map)('ok')({\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(await refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineAsyncResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  async (\n    value: unknown,\n  ): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      const isValid = await check(field); // ✅ Async validation\n      if (!isValid) return null;\n    }\n\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Refines a value asynchronously in non-curried call style.\n *\n * @typeParam TMap - The variant configuration map type.\n * @typeParam K - The target variant key.\n * @typeParam TValidators - The async validator map for payload fields.\n * @param value - The value to validate and refine.\n * @param variant - The target variant key.\n * @param variantMap - The variant configuration map.\n * @param validators - The async payload validators.\n * @returns A promise resolving to the refined value or `null`.\n * @remarks\n * This export is kept for compatibility. Prefer {@link refineAsyncResultU}\n * from `refineAsyncResultU.ts` as the canonical non-curried entry point.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result/src/refiners/refineAsyncResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> =>\n  refineAsyncResult(variantMap)(variant)(validators)(value);\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type { AsyncValidatorFn } from '../types/refiners/AsyncValidatorFn.js';\nimport type { PayloadKeys } from '../types/refiners/PayloadKeys.js';\nimport type { VariantConfig } from '../types/refiners/VariantConfig.js';\nimport type { UniversalAsyncRefinedResult } from './types/index.js';\n\n/** Resolves payload keys from variant configuration. @internal */\nconst getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n\n/**\n * Refines a value asynchronously in non-curried call style.\n *\n * @typeParam TMap - The variant configuration map type.\n * @typeParam K - The target variant key.\n * @typeParam TValidators - The async validator map for payload fields.\n * @param value - The value to validate and refine.\n * @param variant - The target variant key.\n * @param variantMap - The variant configuration map.\n * @param validators - The async payload validators.\n * @returns A promise resolving to the refined value or `null`.\n * @since 0.1.0\n * @see {@link refineAsyncResult} - Curry-style async refiner constructor.\n * @example\n * ```ts\n * import { refineAsyncResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = await refineAsyncResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: async (x: unknown) => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineAsyncResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, AsyncValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): Promise<UniversalAsyncRefinedResult<K, TMap, TValidators> | null> => {\n  // Imperative style with early returns (Rust-style)\n  return (async () => {\n    // Rust-style early returns with Option-like behavior\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    // Payload validation with async validators\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators[key as keyof TValidators];\n      if (!check) continue;\n\n      const field = value[key as string];\n      // Type-safe async validation\n      const isValid = await (check as AsyncValidatorFn)(field);\n      if (!isValid) return null;\n    }\n\n    // Safe cast after all checks\n    return value as UniversalAsyncRefinedResult<K, TMap, TValidators>;\n  })();\n};\n","import type { PayloadKeys } from '../../types/refiners/PayloadKeys.js';\nimport type { VariantConfig } from '../../types/refiners/VariantConfig.js';\n\n/**\n * Normalizes a variant payload configuration into a list of keys.\n *\n * @typeParam C - The variant configuration type.\n * @param config - The variant configuration with payload definition.\n * @returns The payload keys as a readonly array.\n * @since 0.1.0\n * @example\n * ```ts\n * import { getPayloadKeys } from '@resultsafe/core-fp-result/src/refiners/utils/getPayloadKeys.js';\n *\n * const keys = getPayloadKeys({ payload: ['id', 'meta'] } as const);\n * console.log(keys.length); // 2\n * ```\n * @internal\n */\nexport const getPayloadKeys = <C extends VariantConfig>(\n  config: C,\n): readonly PayloadKeys<C>[] => {\n  const p = config.payload;\n  if (p === 'never') return [];\n  return (Array.isArray(p) ? p : [p]) as readonly PayloadKeys<C>[];\n};\n","import { hasOwn, isObject } from '../internal/object.js';\nimport type { PayloadKeys } from '../types/refiners/PayloadKeys.js';\nimport type { ValidatorFn } from '../types/refiners/ValidatorFn.js';\nimport type { VariantConfig } from '../types/refiners/VariantConfig.js';\nimport type { UniversalRefinedResult } from './types/index.js';\nimport { getPayloadKeys } from './utils/index.js';\n\n/**\n * Creates a sync variant refiner with payload validators.\n *\n * @typeParam TMap - The variant configuration map type.\n * @param variantMap - The map describing valid variants and payload fields.\n * @returns A curried refiner factory bound to `variantMap`.\n * @since 0.1.0\n * @see {@link refineResultU} - Direct (non-curried) helper variant.\n * @example\n * ```ts\n * import { refineResult } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const refineOk = refineResult(map)('ok')({\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(refineOk({ type: 'ok', value: 1 })); // { type: 'ok', value: 1 }\n * ```\n * @public\n */\nexport const refineResult =\n  <TMap extends Record<string, VariantConfig>>(variantMap: TMap) =>\n  <K extends keyof TMap & string>(variant: K) =>\n  <TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>>(\n    validators: TValidators,\n  ) =>\n  (value: unknown): UniversalRefinedResult<K, TMap, TValidators> | null => {\n    if (!isObject(value)) return null;\n    if (!hasOwn(value, 'type')) return null;\n\n    const t = value['type'];\n    if (t !== variant) return null;\n\n    const config = variantMap[variant];\n    if (!config) return null;\n\n    const keys = getPayloadKeys(config);\n    for (const key of keys) {\n      const check = validators?.[key];\n      if (!check) continue;\n\n      const field = value[key as keyof typeof value];\n      if (!check(field)) return null;\n    }\n\n    return value as UniversalRefinedResult<K, TMap, TValidators>;\n  };\n\n/**\n * Refines a value by variant map in non-curried call style.\n *\n * @typeParam TMap - The variant configuration map type.\n * @typeParam K - The target variant key.\n * @typeParam TValidators - The validator map for payload fields.\n * @param value - The value to validate and refine.\n * @param variant - The target variant key.\n * @param variantMap - The variant configuration map.\n * @param validators - The payload validators for the target variant.\n * @returns The refined value or `null`.\n * @remarks\n * This export is kept for compatibility. Prefer {@link refineResultU} from\n * `refineResultU.ts` as the canonical non-curried entry point.\n * @since 0.1.0\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result/src/refiners/refineResult.js';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @internal\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): UniversalRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n","import type { PayloadKeys } from '../types/refiners/PayloadKeys.js';\nimport type { ValidatorFn } from '../types/refiners/ValidatorFn.js';\nimport type { VariantConfig } from '../types/refiners/VariantConfig.js';\nimport { refineResult } from './refineResult.js';\nimport type { SyncRefinedResult } from './types/index.js';\n\n/**\n * Refines a value by variant map in non-curried call style.\n *\n * @typeParam TMap - The variant configuration map type.\n * @typeParam K - The target variant key.\n * @typeParam TValidators - The validator map for payload fields.\n * @param value - The value to validate and refine.\n * @param variant - The target variant key.\n * @param variantMap - The variant configuration map.\n * @param validators - The payload validators for the target variant.\n * @returns The refined value or `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Curry-style refiner constructor.\n * @example\n * ```ts\n * import { refineResultU } from '@resultsafe/core-fp-result';\n *\n * const map = { ok: { payload: 'value' } } as const;\n * const out = refineResultU({ type: 'ok', value: 1 }, 'ok', map, {\n *   value: (x: unknown): x is number => typeof x === 'number',\n * });\n *\n * console.log(out?.type); // ok\n * ```\n * @public\n */\nexport const refineResultU = <\n  TMap extends Record<string, VariantConfig>,\n  K extends keyof TMap & string,\n  TValidators extends Partial<Record<PayloadKeys<TMap[K]>, ValidatorFn>>,\n>(\n  value: unknown,\n  variant: K,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResult<K, TMap, TValidators> | null =>\n  refineResult(variantMap)(variant)(validators)(value);\n","import type { PayloadKeys } from '../types/refiners/PayloadKeys.js';\nimport type { ValidatorFn } from '../types/refiners/ValidatorFn.js';\nimport type { VariantConfig } from '../types/refiners/VariantConfig.js';\nimport type { SyncRefinedResultUnion } from './types/SyncRefinedResultUnion.js';\nimport type { SyncValidatorMap } from './types/SyncValidatorMap.js';\n\n/**\n * Refines a discriminated union value by a full variant map.\n *\n * @typeParam TMap - The variant configuration map type.\n * @typeParam TValidators - The validator map type by variant.\n * @param value - The value to validate and refine.\n * @param variantMap - The full variant configuration map.\n * @param validators - The validators grouped by variant key.\n * @returns The refined union member or `null`.\n * @since 0.1.0\n * @see {@link refineResult} - Refines one concrete variant key.\n * @example\n * ```ts\n * import { refineVariantMap } from '@resultsafe/core-fp-result';\n *\n * const map = {\n *   created: { payload: 'id' },\n *   failed: { payload: 'reason' },\n * } as const;\n *\n * const out = refineVariantMap({ type: 'created', id: '1' }, map, {\n *   created: { id: (x: unknown): x is string => typeof x === 'string' },\n *   failed: { reason: (x: unknown): x is string => typeof x === 'string' },\n * });\n *\n * console.log(out?.type); // created\n * ```\n * @public\n */\nexport function refineVariantMap<\n  TMap extends Record<string, VariantConfig>,\n  TValidators extends SyncValidatorMap<TMap>,\n>(\n  value: unknown,\n  variantMap: TMap,\n  validators: TValidators,\n): SyncRefinedResultUnion<TMap, TValidators> | null {\n  if (typeof value !== 'object' || value === null || !('type' in value)) {\n    return null;\n  }\n\n  const rawType = (value as { type?: unknown }).type;\n  if (typeof rawType !== 'string' || !(rawType in variantMap)) return null;\n\n  // fix the specific variant key\n  type K = Extract<keyof TMap, string>;\n  const k = rawType as K;\n\n  const config = variantMap[k];\n  if (!config) return null;\n\n  // payload keys for the specific K\n  const payload = config.payload;\n  const keys = (\n    payload === 'never' ? [] : Array.isArray(payload) ? payload : [payload]\n  ) as readonly PayloadKeys<TMap[typeof k]>[];\n\n  // validators aligned with the specific K\n  const vvs = validators[k] as\n    | Partial<Record<PayloadKeys<TMap[typeof k]>, ValidatorFn>>\n    | undefined;\n\n  if (vvs) {\n    const obj = value as Record<string, unknown>;\n    for (const key of keys) {\n      const check = vvs[key];\n      if (!check) continue;\n      if (!check(obj[key as string])) return null;\n    }\n  }\n\n  return value as SyncRefinedResultUnion<TMap, TValidators>;\n}\n"],"names":["fn","getPayloadKeys"],"mappings":"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"}

package/types/shared-types.d.ts

@@ -1,22 +0,0 @@
-export type Result<T, E> = {
-    readonly ok: true;
-    readonly value: T;
-} | {
-    readonly ok: false;
-    readonly error: E;
-};
-export type Option<T> = {
-    readonly some: true;
-    readonly value: T;
-} | {
-    readonly some: false;
-};
-export interface VariantConfig {
-    readonly payload: 'never' | string | readonly string[];
-    readonly forbidden?: string | undefined;
-    readonly strictFields?: boolean | undefined;
-}
-export type PayloadKeys<T extends VariantConfig> = T['payload'] extends 'never' ? never : T['payload'] extends string ? T['payload'] : T['payload'] extends readonly string[] ? T['payload'][number] : never;
-export type ValidatorFn<T = unknown> = (x: unknown) => x is T;
-export type AsyncValidatorFn = (value: unknown) => Promise<boolean>;
-//# sourceMappingURL=shared-types.d.ts.map

package/types/shared-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared-types.d.ts","sourceRoot":"","sources":["../../src/shared-types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,MAAM,CAAC,CAAC,EAAE,CAAC,IACnB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,CAAC;AAE9C,MAAM,MAAM,MAAM,CAAC,CAAC,IAChB;IAAE,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GAC1C;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAA;CAAE,CAAC;AAE7B,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,MAAM,EAAE,CAAC;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACxC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC7C;AAED,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,CAAC,SAAS,CAAC,SAAS,OAAO,GAC3E,KAAK,GACL,CAAC,CAAC,SAAS,CAAC,SAAS,MAAM,GACzB,CAAC,CAAC,SAAS,CAAC,GACZ,CAAC,CAAC,SAAS,CAAC,SAAS,SAAS,MAAM,EAAE,GACpC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,GACpB,KAAK,CAAC;AAEd,MAAM,MAAM,WAAW,CAAC,CAAC,GAAG,OAAO,IAAI,CAAC,CAAC,EAAE,OAAO,KAAK,CAAC,IAAI,CAAC,CAAC;AAE9D,MAAM,MAAM,gBAAgB,GAAG,CAAC,KAAK,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC"}