chore: use overloaded Moroutine type for cleaner IDE signatures

The first overload shows clean parameter types (no Arg<T> wrappers).
The second overload accepts Task<T> args as a fallback. IDEs display
the clean signature by default.

Co-Authored-By: Claude Opus 4.6 (1M context) <[e-mail]>

src/mo.ts

···
 
 type TaskableArgs<A extends unknown[]> = { [K in keyof A]: Arg<A[K]> };
 
-export function mo<A extends unknown[], R>(
-  importMeta: ImportMeta,
-  fn: (...args: A) => R,
-): (...args: TaskableArgs<A>) => Task<R> {
+type Moroutine<A extends unknown[], R> = {
+  (...args: A): Task<R>;
+  (...args: TaskableArgs<A>): Task<R>;
+};
+
+export function mo<A extends unknown[], R>(importMeta: ImportMeta, fn: (...args: A) => R): Moroutine<A, R> {
   const url = importMeta.url;
 
   if (isModuleFrozen(url)) {
···
 
   registry.set(id, fn);
 
-  return ((...args: unknown[]) => new Task<R>(id, args)) as (...args: TaskableArgs<A>) => Task<R>;
+  return ((...args: unknown[]) => new Task<R>(id, args)) as Moroutine<A, R>;
 }

test/context.test.ts

···
 import { describe, it } from 'node:test';
 import assert from 'node:assert/strict';
 import { workers } from 'moroutine';
-import { makeCtx, identity, readCtx, addWithCtx } from './fixtures/context.ts';
+import { makeCtx, makeMultiplierCtx, readCtx, addWithCtx } from './fixtures/context.ts';
 
 describe('task-arg caching', () => {
   it('task arg is resolved on the worker', async () => {
···
   });
 
   it('task arg works alongside regular args', async () => {
-    const ctx = identity({ multiplier: 3 });
+    const ctx = makeMultiplierCtx(3);
     const run = workers(1);
     try {
       const result = await run(addWithCtx(ctx, 2, 5));

test/fixtures/context.ts

···
   return { value, workerInitId: initCount };
 });
 
-export const identity = mo(import.meta, <T>(value: T): T => value);
+export const makeMultiplierCtx = mo(import.meta, (multiplier: number): { multiplier: number } => {
+  return { multiplier };
+});
 
 export const readCtx = mo(
   import.meta,