export function http<
  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?: HttpListenArg,
): Layer.Layer<Self | Hyperlink.Local<Self> | ListenNode, never, R>;
export function http<
  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 http<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?: HttpListenArg,
): Layer.Layer<Self | Hyperlink.Local<Self> | ListenNode, never, R>;
export function http<A, E, R>(
  serve: Layer.Layer<A, E, R>,
  options?: HttpListenArg,
): Layer.Layer<A | ListenNode, E, R>;
export function http<const Serves extends ServeLayerList>(
  serves: Serves,
  options?: HttpListenArg,
): Layer.Layer<
  Layer.Success<Serves[number]> | ListenNode,
  Layer.Error<Serves[number]>,
  Layer.Services<Serves[number]>
>;
export function http<Node extends AnyNode, A, E, R>(
  node: Node,
  serve: Layer.Layer<A, E, R>,
  options?: HttpListenArg,
): Layer.Layer<A | ListenNode, E, R>;
export function http<
  Node extends AnyNode & { readonly [catalogSym]?: unknown },
  const Serves extends ServeLayerList,
>(
  node: Node,
  serves: Serves & ServesForCatalog<CatalogROut<Node>, Serves>,
  options?: HttpListenArg,
): Layer.Layer<
  Layer.Success<Serves[number]> | ListenNode,
  Layer.Error<Serves[number]>,
  Layer.Services<Serves[number]>
>;
export function http(
  nodeOrServesOrTag:
    | AnyNode
    | Layer.Any
    | ServeLayerList
    | Hyperlink.PipeableTag,
  servesOrOptionsOrImpl?:
    | Layer.Any
    | ServeLayerList
    | HttpListenArg
    | AnyNode
    | object,
  options?: HttpListenArg | AnyNode,
): Layer.Any {
  // Lookup is not baked in — pipe `Layer.provide(Lookup.layer)` (default) or
  // `Lookup.layerOptions({ path })` / `Lookup.client` when claim / advertise needs it.

  if (isServeArg(nodeOrServesOrTag)) {
    const list = (
      Array.isArray(nodeOrServesOrTag)
        ? nodeOrServesOrTag
        : [nodeOrServesOrTag]
    ) as ServeLayerList;
    return httpNameless(
      list,
      coerceHttpListenOptions(servesOrOptionsOrImpl as HttpListenArg | undefined),
    );
  }

  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 listenOptions = coerceHttpListenOptions(
      resolved.addressArg as HttpListenArg | undefined,
    );
    if (resolved._tag === "nameless") {
      return httpNameless(list, listenOptions);
    }
    const node = resolved.node;
    if (isNonHttpNode(node)) {
      return httpRequiresHttpLayer(
        node.key,
        node.kind ??
          (typeof node.path === "string"
            ? "IpcSocket"
            : typeof node.url === "string"
              ? "url"
              : "unknown"),
      );
    }
    return httpListenOn(node, list, listenOptions);
  }

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

  const serves = servesOrOptionsOrImpl as
    | Layer.Layer<never, never, never>
    | ServeLayerList;
  const list = (Array.isArray(serves) ? serves : [serves]) as ServeLayerList;
  return httpListenOn(
    node,
    list,
    coerceHttpListenOptions(options as HttpListenArg | undefined),
  );
}