@nicolastoulemont/std 0.3.0 → 0.4.0

package/dist/{equality-YMebYwm1.mjs → equality-C2l3BIi8.mjs}

@@ -101,26 +101,26 @@ function deepEquals(a, b) {
 * Create an equals method for a specific record type.
 *
 * Returns a function that compares two values of the same record type.
-* Returns false if either value doesn't have the expected __typename.
+* Returns false if either value doesn't have the expected _tag.
 *
-* @template Typename - The discriminator string literal type
-* @template T - The record's data type (excluding __typename)
-* @param __typename - The expected __typename discriminator value
+* @template Tag - The discriminator string literal type
+* @template T - The record's data type (excluding _tag)
+* @param _tag - The expected _tag discriminator value
 * @returns A binary equality function for the record type
 *
 * @example
 * ```ts
 * const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')
 * equalsPoint(
-*   { __typename: 'Point', x: 1, y: 2 },
-*   { __typename: 'Point', x: 1, y: 2 }
+*   { _tag: 'Point', x: 1, y: 2 },
+*   { _tag: 'Point', x: 1, y: 2 }
 * ) // true
 * ```
 */
-function createEqualsMethod(__typename) {
+function createEqualsMethod(_tag) {
 	return (a, b) => {
 		if (a === b) return true;
-		if (a.__typename !== __typename || b.__typename !== __typename) return false;
+		if (a._tag !== _tag || b._tag !== _tag) return false;
 		return deepEquals(a, b);
 	};
 }
@@ -128,22 +128,22 @@ function createEqualsMethod(__typename) {
 * Create a hash method for a specific record type.
 *
 * Returns a function that computes a hash code for values of the record type.
-* Returns 0 if the value doesn't have the expected __typename.
+* Returns 0 if the value doesn't have the expected _tag.
 *
-* @template Typename - The discriminator string literal type
-* @template T - The record's data type (excluding __typename)
-* @param __typename - The expected __typename discriminator value
+* @template Tag - The discriminator string literal type
+* @template T - The record's data type (excluding _tag)
+* @param _tag - The expected _tag discriminator value
 * @returns A unary hash function for the record type
 *
 * @example
 * ```ts
 * const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')
-* hashPoint({ __typename: 'Point', x: 1, y: 2 }) // number
+* hashPoint({ _tag: 'Point', x: 1, y: 2 }) // number
 * ```
 */
-function createHashMethod(__typename) {
+function createHashMethod(_tag) {
 	return (value) => {
-		if (value.__typename !== __typename) return 0;
+		if (value._tag !== _tag) return 0;
 		return deepHash(value);
 	};
 }
@@ -151,24 +151,24 @@ function createHashMethod(__typename) {
 * Create an equals method for an ADT (any variant).
 *
 * Returns a function that compares two ADT values for structural equality.
-* Values must have the same __typename and be a known variant.
+* Values must have the same _tag and be a known variant.
 *
-* @template T - The ADT type (union of all variants with __typename)
-* @param typenames - Array of valid __typename values for this ADT
+* @template T - The ADT type (union of all variants with _tag)
+* @param tags - Array of valid _tag values for this ADT
 * @returns A binary equality function for any variant of the ADT
 *
 * @example
 * ```ts
 * const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])
 * equalsShape(circle1, circle2) // true if structurally equal
-* equalsShape(circle, square) // false (different __typename)
+* equalsShape(circle, square) // false (different _tag)
 * ```
 */
-function createADTEqualsMethod(typenames) {
+function createADTEqualsMethod(tags) {
 	return (a, b) => {
 		if (a === b) return true;
-		if (a.__typename !== b.__typename) return false;
-		if (!typenames.includes(a.__typename)) return false;
+		if (a._tag !== b._tag) return false;
+		if (!tags.includes(a._tag)) return false;
 		return deepEquals(a, b);
 	};
 }
@@ -176,10 +176,10 @@ function createADTEqualsMethod(typenames) {
 * Create a hash method for an ADT (any variant).
 *
 * Returns a function that computes a hash code for any variant of the ADT.
-* Returns 0 if the value's __typename is not a known variant.
+* Returns 0 if the value's _tag is not a known variant.
 *
-* @template T - The ADT type (union of all variants with __typename)
-* @param typenames - Array of valid __typename values for this ADT
+* @template T - The ADT type (union of all variants with _tag)
+* @param tags - Array of valid _tag values for this ADT
 * @returns A unary hash function for any variant of the ADT
 *
 * @example
@@ -189,13 +189,13 @@ function createADTEqualsMethod(typenames) {
 * hashShape(square) // number
 * ```
 */
-function createADTHashMethod(typenames) {
+function createADTHashMethod(tags) {
 	return (value) => {
-		if (!typenames.includes(value.__typename)) return 0;
+		if (!tags.includes(value._tag)) return 0;
 		return deepHash(value);
 	};
 }
 
 //#endregion
 export { deepEquals as a, createHashMethod as i, createADTHashMethod as n, deepHash as o, createEqualsMethod as r, createADTEqualsMethod as t };
-//# sourceMappingURL=equality-YMebYwm1.mjs.map
+//# sourceMappingURL=equality-C2l3BIi8.mjs.map

package/dist/equality-C2l3BIi8.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"equality-C2l3BIi8.mjs","names":[],"sources":["../src/equality/equality.ts"],"sourcesContent":["import type { Discriminator } from \"../shared/discriminator.types\"\n\n// ============================================================================\n// Hashing (FNV-1a inspired algorithm)\n// ============================================================================\n\nconst FNV_OFFSET = 2166136261\nconst FNV_PRIME = 16777619\n\n/**\n * Compute a 32-bit hash code for any value using an FNV-1a inspired algorithm.\n *\n * Handles: primitives, null, undefined, Date, arrays, and plain objects.\n * Object keys are sorted for deterministic hashing regardless of insertion order.\n *\n * @param value - The value to hash (any type)\n * @returns A 32-bit unsigned integer hash code\n *\n * @example\n * ```ts\n * deepHash({ a: 1, b: 2 }) // deterministic number\n * deepHash({ b: 2, a: 1 }) // same number (keys sorted)\n * deepHash([1, 2, 3]) === deepHash([1, 2, 3]) // true\n * ```\n */\nexport function deepHash(value: unknown): number {\n  let hash = FNV_OFFSET\n\n  // \"null\" as hex\n  if (value === null) return hash ^ 0x6e756c6c\n  // \"unde\" as hex\n  if (value === undefined) return hash ^ 0x756e6465\n\n  /* oxlint-disable unicorn/prefer-math-trunc, no-case-declarations, switch-exhaustiveness-check -- Bitwise ops are intentional for FNV-1a hash: | 0 truncates to signed 32-bit, >>> 0 converts to unsigned 32-bit (Math.trunc cannot do this). Default case handles function, symbol, bigint. */\n  switch (typeof value) {\n    case \"boolean\":\n      return hash ^ (value ? 1 : 0)\n\n    case \"number\": {\n      // Handle special cases: \"NaN\" as hex\n      if (Number.isNaN(value)) return hash ^ 0x4e614e\n      if (!Number.isFinite(value)) return hash ^ (value > 0 ? 0x496e66 : 0x2d496e66)\n      // Mix the number bits into hash\n      return hash ^ (value | 0) ^ ((value * 1000000) | 0)\n    }\n\n    case \"string\":\n      for (let i = 0; i < value.length; i++) {\n        hash ^= value.codePointAt(i)!\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      // Convert to unsigned 32-bit\n      return hash >>> 0\n\n    case \"object\": {\n      if (value instanceof Date) {\n        return hash ^ deepHash(value.getTime())\n      }\n\n      if (Array.isArray(value)) {\n        // \"[]\" as hex\n        hash ^= 0x5b5d\n        for (let i = 0; i < value.length; i++) {\n          hash ^= deepHash(value[i])\n          hash = Math.imul(hash, FNV_PRIME)\n        }\n        return hash >>> 0\n      }\n\n      // Plain object: \"{}\" as hex\n      hash ^= 0x7b7d\n      // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object iteration\n      const obj = value as Record<string, unknown>\n      // Sort keys for consistency\n      const keys = Object.keys(obj).toSorted()\n      for (const key of keys) {\n        hash ^= deepHash(key)\n        hash = Math.imul(hash, FNV_PRIME)\n        hash ^= deepHash(obj[key])\n        hash = Math.imul(hash, FNV_PRIME)\n      }\n      return hash >>> 0\n    }\n\n    default:\n      // Handles: function, symbol, bigint\n      return hash\n  }\n  /* oxlint-enable unicorn/prefer-math-trunc, no-case-declarations */\n}\n\n// ============================================================================\n// Equality\n// ============================================================================\n\n/**\n * Deep structural equality comparison for two values.\n *\n * Compares by value rather than reference. Handles:\n * - Primitives (===)\n * - null and undefined\n * - Date objects (by timestamp)\n * - Arrays (element-wise, same length required)\n * - Plain objects (key-value pairs, same keys required)\n *\n * @param a - First value to compare\n * @param b - Second value to compare\n * @returns true if values are structurally equal\n *\n * @example\n * ```ts\n * deepEquals({ x: 1 }, { x: 1 }) // true\n * deepEquals([1, 2], [1, 2]) // true\n * deepEquals(new Date(0), new Date(0)) // true\n * deepEquals({ a: 1 }, { a: 1, b: 2 }) // false (different keys)\n * ```\n */\nexport function deepEquals(a: unknown, b: unknown): boolean {\n  // Same reference or both null/undefined\n  if (a === b) return true\n\n  // Different types\n  if (typeof a !== typeof b) return false\n\n  // Handle null\n  if (a === null || b === null) return false\n\n  // Primitives (already checked === above)\n  if (typeof a !== \"object\") return false\n\n  // Date comparison\n  if (a instanceof Date && b instanceof Date) {\n    return a.getTime() === b.getTime()\n  }\n\n  // Array comparison\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false\n    return a.every((item, index) => deepEquals(item, b[index]))\n  }\n\n  // Plain object comparison\n  if (Array.isArray(a) !== Array.isArray(b)) return false\n\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const aObj = a as Record<string, unknown>\n  // oxlint-disable-next-line no-unsafe-type-assertion -- Required for object comparison\n  const bObj = b as Record<string, unknown>\n\n  const aKeys = Object.keys(aObj)\n  const bKeys = Object.keys(bObj)\n\n  if (aKeys.length !== bKeys.length) return false\n\n  return aKeys.every((key) => deepEquals(aObj[key], bObj[key]))\n}\n\n// ============================================================================\n// Factory Functions\n// ============================================================================\n\n/**\n * Create an equals method for a specific record type.\n *\n * Returns a function that compares two values of the same record type.\n * Returns false if either value doesn't have the expected _tag.\n *\n * @template Tag - The discriminator string literal type\n * @template T - The record's data type (excluding _tag)\n * @param _tag - The expected _tag discriminator value\n * @returns A binary equality function for the record type\n *\n * @example\n * ```ts\n * const equalsPoint = createEqualsMethod<'Point', { x: number; y: number }>('Point')\n * equalsPoint(\n *   { _tag: 'Point', x: 1, y: 2 },\n *   { _tag: 'Point', x: 1, y: 2 }\n * ) // true\n * ```\n */\nexport function createEqualsMethod<Tag extends string, T>(\n  _tag: Tag,\n): (a: T & Discriminator<Tag>, b: T & Discriminator<Tag>) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a._tag !== _tag || b._tag !== _tag) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for a specific record type.\n *\n * Returns a function that computes a hash code for values of the record type.\n * Returns 0 if the value doesn't have the expected _tag.\n *\n * @template Tag - The discriminator string literal type\n * @template T - The record's data type (excluding _tag)\n * @param _tag - The expected _tag discriminator value\n * @returns A unary hash function for the record type\n *\n * @example\n * ```ts\n * const hashPoint = createHashMethod<'Point', { x: number; y: number }>('Point')\n * hashPoint({ _tag: 'Point', x: 1, y: 2 }) // number\n * ```\n */\nexport function createHashMethod<Tag extends string, T>(_tag: Tag): (value: T & Discriminator<Tag>) => number {\n  return (value) => {\n    if (value._tag !== _tag) return 0\n    return deepHash(value)\n  }\n}\n\n/**\n * Create an equals method for an ADT (any variant).\n *\n * Returns a function that compares two ADT values for structural equality.\n * Values must have the same _tag and be a known variant.\n *\n * @template T - The ADT type (union of all variants with _tag)\n * @param tags - Array of valid _tag values for this ADT\n * @returns A binary equality function for any variant of the ADT\n *\n * @example\n * ```ts\n * const equalsShape = createADTEqualsMethod<Circle | Square>(['Circle', 'Square'])\n * equalsShape(circle1, circle2) // true if structurally equal\n * equalsShape(circle, square) // false (different _tag)\n * ```\n */\nexport function createADTEqualsMethod<T extends { readonly _tag: string }>(tags: string[]): (a: T, b: T) => boolean {\n  return (a, b) => {\n    if (a === b) return true\n    if (a._tag !== b._tag) return false\n    if (!tags.includes(a._tag)) return false\n    return deepEquals(a, b)\n  }\n}\n\n/**\n * Create a hash method for an ADT (any variant).\n *\n * Returns a function that computes a hash code for any variant of the ADT.\n * Returns 0 if the value's _tag is not a known variant.\n *\n * @template T - The ADT type (union of all variants with _tag)\n * @param tags - Array of valid _tag values for this ADT\n * @returns A unary hash function for any variant of the ADT\n *\n * @example\n * ```ts\n * const hashShape = createADTHashMethod<Circle | Square>(['Circle', 'Square'])\n * hashShape(circle) // number\n * hashShape(square) // number\n * ```\n */\nexport function createADTHashMethod<T extends { readonly _tag: string }>(tags: string[]): (value: T) => number {\n  return (value) => {\n    if (!tags.includes(value._tag)) return 0\n    return deepHash(value)\n  }\n}\n"],"mappings":"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"}

package/dist/err/index.d.mts

@@ -1,2 +1,2 @@
-import { a as TaggedError$1, i as ErrorTag, n as TaggedError, o as TaggedErrorFactory, r as ErrorData, s as TaggedErrorInstance, t as Err } from "../index-BR7takNf.mjs";
-export { Err, ErrorData, ErrorTag, TaggedError, TaggedErrorFactory, TaggedErrorInstance, TaggedError$1 as TaggedErrorType };
+import { a as ErrorData, c as TaggedErrorFactory, i as tagged, l as TaggedErrorInstance, n as TaggedError, o as ErrorTag, r as is, s as TaggedError$1, t as Err } from "../index-CQxzD1YM.mjs";
+export { Err, ErrorData, ErrorTag, TaggedError, TaggedErrorFactory, TaggedErrorInstance, TaggedError$1 as TaggedErrorType, is, tagged };

package/dist/err/index.mjs

@@ -1,3 +1,3 @@
-import { n as TaggedError, t as Err } from "../err-BqQApH9r.mjs";
+import { i as tagged, n as TaggedError, r as is, t as Err } from "../err-BM-svBaK.mjs";
 
-export { Err, TaggedError };
+export { Err, TaggedError, is, tagged };

package/dist/{err-BqQApH9r.mjs → err-BM-svBaK.mjs}

@@ -1,3 +1,5 @@
+import { t as FxTypeId } from "./fx.types-DpIQILok.mjs";
+
 //#region src/err/err.ts
 /**
 * Create a constructor function for a tagged error type.
@@ -5,7 +7,7 @@
 * If the error has data, returns a function that requires the data object.
 *
 * @template E - The tagged error type
-* @param tag - The error tag (must match E's __typename)
+* @param tag - The error tag (must match E's _tag)
 * @returns A constructor function for the error type
 *
 * @example
@@ -14,18 +16,18 @@
 * type NotFoundError = TaggedError<"NotFoundError", { resourceId: string }>
 * const NotFound = Err.tagged<NotFoundError>("NotFoundError")
 * const err = NotFound({ resourceId: "user-123" })
-* // { __typename: "NotFoundError", resourceId: "user-123" }
+* // { _tag: "NotFoundError", resourceId: "user-123" }
 *
 * // Error without data
 * type UnauthorizedError = TaggedError<"UnauthorizedError">
 * const Unauthorized = Err.tagged<UnauthorizedError>("UnauthorizedError")
 * const err = Unauthorized()
-* // { __typename: "UnauthorizedError" }
+* // { _tag: "UnauthorizedError" }
 * ```
 */
 const tagged = (tag) => {
 	return ((data) => ({
-		__typename: tag,
+		_tag: tag,
 		...data
 	}));
 };
@@ -45,7 +47,7 @@ const tagged = (tag) => {
 * class NotFoundError extends TaggedError("NotFoundError")<{ id: string }> {}
 * const err = new NotFoundError({ id: "123" })
 * err.id // "123"
-* err.__typename // "NotFoundError"
+* err._tag // "NotFoundError"
 * err.stack // Error stack trace
 *
 * // Error without data
@@ -53,7 +55,7 @@ const tagged = (tag) => {
 * const err2 = new UnauthorizedError()
 *
 * // Direct yielding in Do computation
-* const program = gen(function* () {
+* const program = Fx.gen(function* () {
 *   yield* new NotFoundError({ id: "123" })  // Short-circuits with error
 * })
 *
@@ -65,8 +67,13 @@ const tagged = (tag) => {
 */
 function TaggedError(tag) {
 	return class TaggedErrorImpl extends Error {
-		static __typename = tag;
-		__typename = tag;
+		static _tag = tag;
+		_tag = tag;
+		[FxTypeId] = {
+			_A: () => void 0,
+			_E: () => this,
+			_R: () => void 0
+		};
 		constructor(...args) {
 			super(tag);
 			this.name = tag;
@@ -111,12 +118,12 @@ function TaggedError(tag) {
 * ```
 */
 const is = (tag) => {
-	return (error) => typeof error === "object" && error !== null && "__typename" in error && error.__typename === tag;
+	return (error) => typeof error === "object" && error !== null && "_tag" in error && error._tag === tag;
 };
 /**
 * Err namespace containing utilities for creating and checking tagged errors.
 *
-* Tagged errors are plain objects with a `__typename` discriminator field,
+* Tagged errors are plain objects with a `_tag` discriminator field,
 * making them serializable and easy to pattern match.
 *
 * @example
@@ -140,7 +147,7 @@ const is = (tag) => {
 * }
 *
 * // Use with Do computation
-* const program = gen(function* () {
+* const program = Fx.gen(function* () {
 *   const user = yield* findUser("123")
 *   return user
 * })
@@ -165,5 +172,5 @@ const Err = {
 };
 
 //#endregion
-export { TaggedError as n, Err as t };
-//# sourceMappingURL=err-BqQApH9r.mjs.map
+export { tagged as i, TaggedError as n, is as r, Err as t };
+//# sourceMappingURL=err-BM-svBaK.mjs.map

package/dist/err-BM-svBaK.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"err-BM-svBaK.mjs","names":[],"sources":["../src/err/err.ts"],"sourcesContent":["import { FxTypeId } from \"../fx/fx.types\"\nimport type { TaggedError, TaggedErrorFactory } from \"./err.types\"\n\n/**\n * Helper type to extract data fields from a TaggedError (excluding _tag and Fx protocol)\n */\ntype DataOf<E extends TaggedError<string>> = Omit<E, \"_tag\" | typeof FxTypeId | typeof Symbol.iterator>\n\n/**\n * Helper type to check if data is empty (only has _tag)\n */\ntype IsEmptyData<Data> = keyof Data extends never ? true : false\n\n/**\n * Create a constructor function for a tagged error type.\n * If the error has no additional data, returns a function that takes no arguments.\n * If the error has data, returns a function that requires the data object.\n *\n * @template E - The tagged error type\n * @param tag - The error tag (must match E's _tag)\n * @returns A constructor function for the error type\n *\n * @example\n * ```ts\n * // Error with data\n * type NotFoundError = TaggedError<\"NotFoundError\", { resourceId: string }>\n * const NotFound = Err.tagged<NotFoundError>(\"NotFoundError\")\n * const err = NotFound({ resourceId: \"user-123\" })\n * // { _tag: \"NotFoundError\", resourceId: \"user-123\" }\n *\n * // Error without data\n * type UnauthorizedError = TaggedError<\"UnauthorizedError\">\n * const Unauthorized = Err.tagged<UnauthorizedError>(\"UnauthorizedError\")\n * const err = Unauthorized()\n * // { _tag: \"UnauthorizedError\" }\n * ```\n */\nexport const tagged: <E extends TaggedError<string>>(\n  tag: E[\"_tag\"],\n) => IsEmptyData<DataOf<E>> extends true ? () => E : (data: DataOf<E>) => E = (tag) => {\n  return ((data?: object) => ({ _tag: tag, ...data })) as never\n}\n\n/**\n * Create a class-based tagged error type (Effect-style syntax).\n * Returns a class that can be extended to create custom error types.\n * Errors are native Error objects with proper stack traces and instanceof support.\n * Implements Yieldable protocol so errors can be directly yielded in Do computations.\n *\n * @template Tag - The error tag (discriminator string)\n * @param tag - The error tag\n * @returns A class that can be extended with custom data\n *\n * @example\n * ```ts\n * // Error with data\n * class NotFoundError extends TaggedError(\"NotFoundError\")<{ id: string }> {}\n * const err = new NotFoundError({ id: \"123\" })\n * err.id // \"123\"\n * err._tag // \"NotFoundError\"\n * err.stack // Error stack trace\n *\n * // Error without data\n * class UnauthorizedError extends TaggedError(\"UnauthorizedError\") {}\n * const err2 = new UnauthorizedError()\n *\n * // Direct yielding in Do computation\n * const program = Fx.gen(function* () {\n *   yield* new NotFoundError({ id: \"123\" })  // Short-circuits with error\n * })\n *\n * // instanceof checks work\n * if (err instanceof NotFoundError) {\n *   console.log(err.id)\n * }\n * ```\n */\nexport function TaggedError<Tag extends string>(tag: Tag): TaggedErrorFactory<Tag> {\n  return class TaggedErrorImpl<Data extends object = object> extends Error {\n    static readonly _tag: Tag = tag\n    readonly _tag: Tag = tag\n\n    readonly [FxTypeId] = {\n      _A: () => undefined as never,\n      _E: () => this as TaggedErrorImpl<Data>,\n      _R: () => undefined as never,\n    }\n\n    constructor(...args: keyof Data extends never ? [] : [data: Data]) {\n      super(tag)\n      this.name = tag\n      const data = args[0]\n      if (data) Object.assign(this, data)\n      Object.setPrototypeOf(this, new.target.prototype)\n    }\n\n    *[Symbol.iterator](): Generator<this, never, unknown> {\n      yield this\n      throw new Error(\"Unreachable: Do should short-circuit on error\")\n    }\n  } as unknown as TaggedErrorFactory<Tag>\n}\n\n/**\n * Create a type guard for a tagged error type.\n * Returns a curried function that checks if a value is the specified error type.\n *\n * @template E - The tagged error type to check for\n * @param tag - The error tag to match\n * @returns A type guard function\n *\n * @example\n * ```ts\n * type NotFoundError = TaggedError<\"NotFoundError\", { id: string }>\n *\n * const error: unknown = getError()\n *\n * if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *   console.log(error.id) // TypeScript knows error is NotFoundError\n * }\n *\n * // Works with union error types\n * type AppError = NotFoundError | ValidationError | DbError\n *\n * function handleError(error: AppError) {\n *   if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *     // Handle not found\n *   } else if (Err.is<ValidationError>(\"ValidationError\")(error)) {\n *     // Handle validation error\n *   }\n * }\n * ```\n */\nexport const is = <E extends TaggedError<string>>(tag: E[\"_tag\"]): ((error: unknown) => error is E) => {\n  return (error: unknown): error is E =>\n    typeof error === \"object\" && error !== null && \"_tag\" in error && error._tag === tag\n}\n\n/**\n * Err namespace containing utilities for creating and checking tagged errors.\n *\n * Tagged errors are plain objects with a `_tag` discriminator field,\n * making them serializable and easy to pattern match.\n *\n * @example\n * ```ts\n * import { Err, Result, Do } from \"@repo/std\"\n * import type { TaggedError } from \"@repo/std\"\n *\n * // Define error types\n * type NotFoundError = TaggedError<\"NotFoundError\", { resourceId: string }>\n * type ValidationError = TaggedError<\"ValidationError\", { field: string; message: string }>\n *\n * // Create constructors\n * const NotFound = Err.tagged<NotFoundError>(\"NotFoundError\")\n * const Validation = Err.tagged<ValidationError>(\"ValidationError\")\n *\n * // Use with Result\n * function findUser(id: string): Result<User, NotFoundError> {\n *   const user = db.find(id)\n *   if (!user) return Result.err(NotFound({ resourceId: id }))\n *   return Result.ok(user)\n * }\n *\n * // Use with Do computation\n * const program = Fx.gen(function* () {\n *   const user = yield* findUser(\"123\")\n *   return user\n * })\n *\n * // Pattern match on error types\n * pipe(\n *   program.run(),\n *   Result.match({\n *     ok: (user) => console.log(user),\n *     err: (error) => {\n *       if (Err.is<NotFoundError>(\"NotFoundError\")(error)) {\n *         console.log(`Not found: ${error.resourceId}`)\n *       }\n *     }\n *   })\n * )\n * ```\n */\nexport const Err = {\n  tagged,\n  is,\n} as const\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,MAAa,UAEkE,QAAQ;AACrF,UAAS,UAAmB;EAAE,MAAM;EAAK,GAAG;EAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCpD,SAAgB,YAAgC,KAAmC;AACjF,QAAO,MAAM,wBAAsD,MAAM;EACvE,OAAgB,OAAY;EAC5B,AAAS,OAAY;EAErB,CAAU,YAAY;GACpB,UAAU;GACV,UAAU;GACV,UAAU;GACX;EAED,YAAY,GAAG,MAAoD;AACjE,SAAM,IAAI;AACV,QAAK,OAAO;GACZ,MAAM,OAAO,KAAK;AAClB,OAAI,KAAM,QAAO,OAAO,MAAM,KAAK;AACnC,UAAO,eAAe,MAAM,IAAI,OAAO,UAAU;;EAGnD,EAAE,OAAO,YAA6C;AACpD,SAAM;AACN,SAAM,IAAI,MAAM,gDAAgD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCtE,MAAa,MAAqC,QAAqD;AACrG,SAAQ,UACN,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,SAAS,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDrF,MAAa,MAAM;CACjB;CACA;CACD"}

package/dist/flow/index.d.mts

@@ -1,2 +1,2 @@
-import { t as flow } from "../index-tkgTLCoq.mjs";
+import { t as flow } from "../index-BOrJQBPO.mjs";
 export { flow };

package/dist/flow/index.mjs

@@ -1,3 +1,3 @@
-import { t as flow } from "../flow-pRdnqmMY.mjs";
+import { t as flow } from "../flow-D4cE0EAg.mjs";
 
 export { flow };

package/dist/{flow-pRdnqmMY.mjs → flow-D4cE0EAg.mjs}

@@ -1,5 +1,12 @@
-import { t as isPromise } from "./is-promise-BEl3eGZg.mjs";
+//#region src/shared/is-promise.ts
+/**
+* Check if a value is a Promise.
+*/
+function isPromise(value) {
+	return value instanceof Promise;
+}
 
+//#endregion
 //#region src/flow/flow.ts
 function flow(...fns) {
 	return ((...args) => {
@@ -17,5 +24,5 @@ const resolveAsync = async (result, funs) => {
 };
 
 //#endregion
-export { flow as t };
-//# sourceMappingURL=flow-pRdnqmMY.mjs.map
+export { isPromise as n, flow as t };
+//# sourceMappingURL=flow-D4cE0EAg.mjs.map

package/dist/flow-D4cE0EAg.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"flow-D4cE0EAg.mjs","names":[],"sources":["../src/shared/is-promise.ts","../src/flow/flow.ts"],"sourcesContent":["/**\n * Check if a value is a Promise.\n */\nexport function isPromise(value: unknown): value is Promise<unknown> {\n  return value instanceof Promise\n}\n","import { isPromise } from \"../shared/is-promise\"\nimport type { λ } from \"../shared/lambda.types\"\nimport type { FlowdFun } from \"./flow.types\"\n\n/**\n * Given a list of functions returns a function that will execute the given\n * functions one after another, always passing the result of the previous\n * function as an argument to the next function.\n *\n * If one of the given functions returns a promise, the promise will be resolved\n * before being passed to the next function.\n *\n * Type inference: This function provides automatic type inference for chains of\n * 1-15 functions. Each function's parameter type is automatically inferred from\n * the previous function's return type. For chains longer than 15 functions,\n * types must be explicitly specified.\n *\n * Async support: Functions can return Promises. The runtime automatically awaits\n * Promises before passing values to subsequent functions, and parameter types\n * use `Awaited<T>` to reflect this behavior. The final return type will be\n * Promise<T> if any function returns a Promise.\n *\n * @see {@link pipe} for immediate execution with an initial value\n *\n * @example\n * ```typescript\n * const join = (...chars: string[]) => chars.join('')\n * flow(join, parseInt)('1', '2', '3')  // -> 123\n *\n * const square = (n: number) => n ** 2\n *\n * // this is equivalent to: square(square(square(2)))\n * flow(square, square, square)(2)  // -> 256\n *\n * // Type inference in action\n * const fn = flow(\n *   (n: number) => n * 2,      // First function must be typed\n *   (n) => n + 1,               // n: number (inferred!)\n *   (n) => n.toString()         // n: number (inferred!)\n * )\n *\n * // also works with promises:\n * // fetchNumber :: async () => Promise<number>\n * flow(fetchNumber, n => n.toString())  // async () => Promise<string>\n * ```\n */\n// 1 function\nexport function flow<A extends unknown[], B>(f1: (...args: A) => B): FlowdFun<[typeof f1]>\n// 2 functions\nexport function flow<A extends unknown[], B, C>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n): FlowdFun<[typeof f1, typeof f2]>\n// 3 functions\nexport function flow<A extends unknown[], B, C, D>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n): FlowdFun<[typeof f1, typeof f2, typeof f3]>\n// 4 functions\nexport function flow<A extends unknown[], B, C, D, E>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4]>\n// 5 functions\nexport function flow<A extends unknown[], B, C, D, E, F>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5]>\n// 6 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6]>\n// 7 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7]>\n// 8 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8]>\n// 9 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n): FlowdFun<[typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9]>\n// 10 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n): FlowdFun<\n  [typeof f1, typeof f2, typeof f3, typeof f4, typeof f5, typeof f6, typeof f7, typeof f8, typeof f9, typeof f10]\n>\n// 11 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n  ]\n>\n// 12 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n  ]\n>\n// 13 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n  ]\n>\n// 14 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n  ]\n>\n// 15 functions\nexport function flow<A extends unknown[], B, C, D, E, F, G, H, I, J, K, L, M, N, O, P>(\n  f1: (...args: A) => B,\n  f2: (arg: Awaited<B>) => C,\n  f3: (arg: Awaited<C>) => D,\n  f4: (arg: Awaited<D>) => E,\n  f5: (arg: Awaited<E>) => F,\n  f6: (arg: Awaited<F>) => G,\n  f7: (arg: Awaited<G>) => H,\n  f8: (arg: Awaited<H>) => I,\n  f9: (arg: Awaited<I>) => J,\n  f10: (arg: Awaited<J>) => K,\n  f11: (arg: Awaited<K>) => L,\n  f12: (arg: Awaited<L>) => M,\n  f13: (arg: Awaited<M>) => N,\n  f14: (arg: Awaited<N>) => O,\n  f15: (arg: Awaited<O>) => P,\n): FlowdFun<\n  [\n    typeof f1,\n    typeof f2,\n    typeof f3,\n    typeof f4,\n    typeof f5,\n    typeof f6,\n    typeof f7,\n    typeof f8,\n    typeof f9,\n    typeof f10,\n    typeof f11,\n    typeof f12,\n    typeof f13,\n    typeof f14,\n    typeof f15,\n  ]\n>\n// Implementation signature (fallback for 16+ functions)\nexport function flow<Fns extends [λ, ...λ[]]>(...fns: Fns): FlowdFun<Fns> {\n  // oxlint-disable-next-line\n  return ((...args) => {\n    // oxlint-disable-next-line\n    let nextArgs: unknown[] = args\n\n    for (let i = 0; i < fns.length; i++) {\n      // oxlint-disable-next-line\n      const [result] = (nextArgs = [fns[i]?.(...nextArgs)])\n      if (isPromise(result)) return resolveAsync(result, fns.slice(i + 1))\n    }\n\n    return nextArgs[0]\n  }) as FlowdFun<Fns>\n}\n\nconst resolveAsync = async (result: unknown, funs: λ[]) => {\n  // oxlint-disable-next-line\n  for (const fun of funs) result = fun(await result)\n  return await result\n}\n"],"mappings":";;;;AAGA,SAAgB,UAAU,OAA2C;AACnE,QAAO,iBAAiB;;;;;ACgS1B,SAAgB,KAA8B,GAAG,KAAyB;AAExE,UAAS,GAAG,SAAS;EAEnB,IAAI,WAAsB;AAE1B,OAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;GAEnC,MAAM,CAAC,UAAW,WAAW,CAAC,IAAI,KAAK,GAAG,SAAS,CAAC;AACpD,OAAI,UAAU,OAAO,CAAE,QAAO,aAAa,QAAQ,IAAI,MAAM,IAAI,EAAE,CAAC;;AAGtE,SAAO,SAAS;;;AAIpB,MAAM,eAAe,OAAO,QAAiB,SAAc;AAEzD,MAAK,MAAM,OAAO,KAAM,UAAS,IAAI,MAAM,OAAO;AAClD,QAAO,MAAM"}

package/dist/fx/index.d.mts

@@ -0,0 +1,3 @@
+import { a as FxError, c as FxSuccess, d as FxYield, f as FxYieldable, g as isServiceRequest, h as SyncFx, i as Fx$1, l as FxTypeId, m as ServiceRequest, n as AsyncFxGenerator, o as FxGenerator, p as RunnableFx, r as AsyncFxYieldable, s as FxRequirements, t as AsyncFx, u as FxValue } from "../fx.types-aTmhyidu.mjs";
+import { A as isFxDefect, C as isServiceClass, D as err, E as FxDefect, M as run, O as fn, S as ServiceOf, T as Fx, _ as createScope, a as Layer$1, b as ServiceClass, c as LayerROut, d as UnprovidedDeps, f as MemoMap, g as ScopeTag, h as ScopeService, i as Layer, j as ok, k as gen, l as MergeError, m as ExcludeScope, n as provideContext, o as LayerError, p as createMemoMap, r as provideService, s as LayerRIn, t as provide, u as MergeROut, v as Context, w as serviceTag, x as ServiceKey, y as Service } from "../index-CLspOlBH.mjs";
+export { AsyncFx, AsyncFxGenerator, AsyncFxYieldable, Context, Context as ContextType, ExcludeScope, Fx, FxDefect, FxError, FxGenerator, Fx$1 as FxProtocol, Fx$1 as FxType, FxRequirements, FxSuccess, FxTypeId, FxValue, FxYield, FxYieldable, Layer, LayerError, LayerRIn, LayerROut, Layer$1 as LayerType, MemoMap, MergeError, MergeROut, RunnableFx, ScopeTag as Scope, ScopeService, Service, ServiceClass, ServiceKey, ServiceOf, ServiceRequest, SyncFx, UnprovidedDeps, createMemoMap, createScope, err, fn, gen, isFxDefect, isServiceClass, isServiceRequest, ok, provide, provideContext, provideService, run, serviceTag };

package/dist/fx/index.mjs

@@ -0,0 +1,4 @@
+import { n as isServiceRequest, t as FxTypeId } from "../fx.types-DpIQILok.mjs";
+import { _ as gen, a as createMemoMap, b as run, c as Layer, d as isServiceClass, f as serviceTag, g as fn, h as err, i as MemoMap, l as Context, m as FxDefect, n as provideContext, o as ScopeTag, p as Fx, r as provideService, s as createScope, t as provide, u as Service, v as isFxDefect, y as ok } from "../fx-B-0MxGTM.mjs";
+
+export { Context, Fx, FxDefect, FxTypeId, Layer, MemoMap, ScopeTag as Scope, Service, createMemoMap, createScope, err, fn, gen, isFxDefect, isServiceClass, isServiceRequest, ok, provide, provideContext, provideService, run, serviceTag };