I believe the issue is that File.Sync() on a stdout that is not fed into a TTY is "not allowed".
On a macOS machine, the error from the example above is:

sync /dev/stdout: inappropriate ioctl for device

This refers to the unix error ENOTTY. I'm not sure what the Windows equivalent of that is.
At least on Unix systems, you can probably guard against this with:

// import "syscall"

err := logger.Sync()
if err != nil && !errors.Is(err, syscall.ENOTTY) {
  fmt.Println(err)
}

Thank you for your help! Unfortunately, it didn't work. On Windows, the error seems to be of type os.PathError

Did a spew.Dump(err) on it:

I did not dare to catch and skip such kind of error, because I might also have a file logger core, which theoretically could run into a real path error!?

Instead I hardened my code bending skills and came up with the following fix. I defined my own implementation of the WriteSyncer, simply wrapping os.Stdout (instead of directly passing it), so I can control what happens when Sync() is called by Zap (spoiler: nothing).

// WrappedWriteSyncer is a helper struct implementing zapcore.WriteSyncer to
// wrap a standard os.Stdout handle, giving control over the WriteSyncer's
// Sync() function. Sync() results in an error on Windows in combination with
// os.Stdout ("sync /dev/stdout: The handle is invalid."). WrappedWriteSyncer
// simply does nothing when Sync() is called by Zap.
type WrappedWriteSyncer struct {
	file *os.File
}

func (mws WrappedWriteSyncer) Write(p []byte) (n int, err error) {
	return mws.file.Write(p)
}
func (mws WrappedWriteSyncer) Sync() error {
	return nil
}

Using it this way:

// Prepare WriteSyncer
ws := zapcore.Lock(WrappedWriteSyncer{os.Stdout})

// Create the core
enc := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
core := zapcore.NewCore(enc, ws, zapcore.DebugLevel)

Additional logger cores / WriteSyncers should not be affected by this and work as usual...

Thanks for the workaround, @noneymous! I'll leave the issue open while the workaround is still needed.
Proper Windows support is something we would like to do in the future (#1000), but it's been pretty low priority.

I have used this method to check if the error is related. I have a Mac system and I get the following error:

sync /dev/stderr: bad file descriptor

err := logger.Sync()
// NOTE: we use syscall.EBADF to check if the error is specifically related to a bad file descriptor,
// which should be the case for if the stderr is a TTY.
if err != nil && (!errors.Is(err, syscall.EBADF) && !errors.Is(err, syscall.ENOTTY)) {
panic(err)
}

EBADF = Errno(0x9)