export function nPipe<
  Self,
  S extends Hyperlink.Spec,
  HSelf,
  R = never,
>(
  tag: Hyperlink.NodeBoundTag<Self, S, HSelf>,
  impl:
    | Hyperlink.ImplOf<S>
    | Hyperlink.Driver<S, R>
    | Effect.Effect<
        Hyperlink.ImplOf<S> | Hyperlink.Driver<S, R>,
        never,
        R
      >,
  options?: IpcListenArg,
): Layer.Layer<Self | Hyperlink.Local<Self> | ListenNode, never, R>;
export function nPipe<
  Self,
  S extends Hyperlink.Spec,
  N extends AnyNode,
  R = never,
>(
  tag: Hyperlink.HyperlinkTag<Self, S>,
  impl:
    | Hyperlink.ImplOf<S>
    | Hyperlink.Driver<S, R>
    | Effect.Effect<
        Hyperlink.ImplOf<S> | Hyperlink.Driver<S, R>,
        never,
        R
      >,
  node: N,
): Layer.Layer<Self | Hyperlink.Local<Self> | ListenNode, never, R>;
export function nPipe<Self, S extends Hyperlink.Spec, R = never>(
  tag: Hyperlink.HyperlinkTag<Self, S>,
  impl:
    | Hyperlink.ImplOf<S>
    | Hyperlink.Driver<S, R>
    | Effect.Effect<
        Hyperlink.ImplOf<S> | Hyperlink.Driver<S, R>,
        never,
        R
      >,
  options?: IpcListenArg,
): Layer.Layer<Self | Hyperlink.Local<Self> | ListenNode, never, R>;
export function nPipe<A, E, R>(
  serve: Layer.Layer<A, E, R>,
  options?: IpcListenArg,
): Layer.Layer<A | ListenNode, E, R>;
export function nPipe<const Serves extends ServeLayerList>(
  serves: Serves,
  options?: IpcListenArg,
): Layer.Layer<
  Layer.Success<Serves[number]> | ListenNode,
  Layer.Error<Serves[number]>,
  Layer.Services<Serves[number]>
>;
export function nPipe<Node extends AnyNode, A, E, R>(
  node: Node,
  serve: Layer.Layer<A, E, R>,
  options?: IpcListenArg,
): Layer.Layer<A | ListenNode, E, R>;
export function nPipe<
  Node extends AnyNode & { readonly [catalogSym]?: unknown },
  const Serves extends ServeLayerList,
>(
  node: Node,
  serves: Serves & ServesForCatalog<CatalogROut<Node>, Serves>,
  options?: IpcListenArg,
): Layer.Layer<
  Layer.Success<Serves[number]> | ListenNode,
  Layer.Error<Serves[number]>,
  Layer.Services<Serves[number]>
>;
export function nPipe(
  nodeOrServesOrTag:
    | AnyNode
    | Layer.Any
    | ServeLayerList
    | Hyperlink.PipeableTag,
  servesOrOptionsOrImpl?:
    | Layer.Any
    | ServeLayerList
    | IpcListenArg
    | AnyNode
    | object,
  options?: IpcListenArg | AnyNode,
): Layer.Any {
  if (isServeArg(nodeOrServesOrTag)) {
    const { options: listenOptions, path: listenPath } = coerceIpcListenArg(
      servesOrOptionsOrImpl as IpcListenArg | undefined,
    );
    const list = (
      Array.isArray(nodeOrServesOrTag)
        ? nodeOrServesOrTag
        : [nodeOrServesOrTag]
    ) as ServeLayerList;
    return requireWindows(nPipeNameless(list, listenOptions, listenPath));
  }

  if (isHyperlinkTagArg(nodeOrServesOrTag)) {
    const tag = nodeOrServesOrTag;
    const resolved = resolveTagListenTarget(tag, options);
    if (resolved._tag === "tagNodeError") {
      return failListenTagNode({
        tag: resolved.tag,
        reason: resolved.reason,
        count: resolved.count,
      });
    }
    const list = serveListFromTagImpl(tag, servesOrOptionsOrImpl);
    const { options: listenOptions, path: listenPath } = coerceIpcListenArg(
      resolved.addressArg as IpcListenArg | undefined,
    );
    if (resolved._tag === "nameless") {
      return requireWindows(nPipeNameless(list, listenOptions, listenPath));
    }
    const node = resolved.node;
    if (isNonIpcNode(node)) {
      return nPipeRequiresIpcLayer(
        node.key,
        node.kind ?? (typeof node.url === "string" ? "url" : "unknown"),
      );
    }
    return requireWindows(
      nPipeListenOn(stampListenPath(node, listenPath), list, listenOptions),
    );
  }

  const node = nodeOrServesOrTag as AnyNode;
  if (isNonIpcNode(node)) {
    return nPipeRequiresIpcLayer(
      node.key,
      node.kind ?? (typeof node.url === "string" ? "url" : "unknown"),
    );
  }

  const { options: listenOptions, path: listenPath } = coerceIpcListenArg(
    options as IpcListenArg | undefined,
  );
  const serves = servesOrOptionsOrImpl as
    | Layer.Layer<never, never, never>
    | ServeLayerList;
  const list = (Array.isArray(serves) ? serves : [serves]) as ServeLayerList;
  return requireWindows(
    nPipeListenOn(stampListenPath(node, listenPath), list, listenOptions),
  );
}